newrelic_rpm 3.6.2.96 → 3.6.3.103.beta

data/lib/new_relic/agent/instrumentation/data_mapper.rb

@@ -207,10 +207,10 @@ module NewRelic
           NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
 
           # Record query duration associated with each of the desired metrics.
-          metrics = [ "ActiveRecord/#{operation}", 'ActiveRecord/all' ]
-          metrics.each do |metric|
-            NewRelic::Agent.record_metric(metric, duration)
-          end
+          metric = "ActiveRecord/#{operation}"
+          rollup_metrics = ActiveRecordHelper.rollup_metrics_for(metric)
+          metrics = [metric] + rollup_metrics
+          NewRelic::Agent.instance.stats_engine.record_metrics(metrics, duration)
         ensure
           super
         end

data/lib/new_relic/agent/instrumentation/metric_frame.rb

@@ -2,26 +2,28 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# This is a legacy support shim now that the MetricFrame functionality has
-# moved over to the Transaction class instead.
-#
-# This class is deprecated and will be removed in a future agent version.
-#
-# This class is not part of the public API.  Avoid making calls on it directly.
-#
 module NewRelic
   module Agent
     module Instrumentation
+      # This is a legacy support shim now that the +MetricFrame+ functionality
+      # has moved over to the +Transaction+ class instead.
+      #
+      # This class is deprecated and will be removed in a future agent version.
+      #
+      # This class is not part of the public API.  Avoid making calls on it directly.
+      #
+      # @deprecated
       class MetricFrame
 
+        # @deprecated
         def self.recording_web_transaction?
           Transaction.recording_web_transaction?
         end
 
+        # @deprecated
         def self.abort_transaction!
           Transaction.abort_transaction!
         end
-
       end
     end
   end

data/lib/new_relic/agent/instrumentation/padrino.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/instrumentation/sinatra'
+
+DependencyDetection.defer do
+  @name = :padrino
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_sinatra] &&
+      defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
+
+    # Our Padrino instrumentation relies heavily on the fact that Padrino is
+    # built on Sinatra. Although it wires up a lot of its own routing logic,
+    # we only need to patch into Padrino's dispatch to get things started.
+    #
+    # Parts of the Sinatra instrumentation (such as the TransactionNamer) are
+    # aware of Padrino as a potential target in areas where both Sinatra and
+    # Padrino run through the same code.
+    module ::Padrino::Routing::InstanceMethods
+      include NewRelic::Agent::Instrumentation::Sinatra
+
+      alias dispatch_without_newrelic dispatch!
+      alias dispatch! dispatch_with_newrelic
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sinatra/ignorer.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Sinatra
+        module Ignorer
+
+          def self.should_ignore?(app, type)
+            return false if !app.settings.respond_to?(:newrelic_ignores)
+
+            app.settings.newrelic_ignores[type].any? do |pattern|
+              pattern.match(app.request.path_info)
+            end
+          end
+
+          def newrelic_ignore(*routes)
+            set_newrelic_ignore(:routes, *routes)
+          end
+
+          def newrelic_ignore_apdex(*routes)
+            set_newrelic_ignore(:apdex, *routes)
+          end
+
+          def newrelic_ignore_enduser(*routes)
+            set_newrelic_ignore(:enduser, *routes)
+          end
+
+          private
+
+          def set_newrelic_ignore(type, *routes)
+            # Important to default this in the context of the actual app
+            # If it's done at register time, ignores end up shared between apps.
+            set :newrelic_ignores, Hash.new([]) if !respond_to?(:newrelic_ignores)
+
+            # If we call an ignore without a route, it applies to the whole app
+            routes = ["*"] if routes.empty?
+
+            settings.newrelic_ignores[type] += routes.map do |r|
+              # Ugly sending to private Base#compile, but we want to mimic
+              # exactly Sinatra's mapping of route text to regex
+              send(:compile, r).first
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sinatra/transaction_namer.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Sinatra
+        module TransactionNamer
+          extend self
+
+          def transaction_name_for_route(env, request)
+            name = route_for_sinatra(env)
+            name = route_name_for_padrino(request) if name.nil?
+
+            transaction_name(name, request) unless name.nil?
+          end
+
+          def initial_transaction_name(request)
+            transaction_name(::NewRelic::Agent::UNKNOWN_METRIC, request)
+          end
+
+          def transaction_name(route_text, request)
+            verb = http_verb(request)
+
+            route_text = route_text.source if route_text.is_a?(Regexp)
+            name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
+            name = "#{verb} #{name}" unless verb.nil?
+            name
+          rescue => e
+            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Sinatra transaction name")
+            ::NewRelic::Agent::UNKNOWN_METRIC
+          end
+
+          def http_verb(request)
+            request.request_method if request.respond_to?(:request_method)
+          end
+
+          # For bare Sinatra, our override on process_route captures the last
+          # route into the environment for us to use later on
+          def route_for_sinatra(env)
+            env["newrelic.last_route"]
+          end
+
+          # For Padrino, the request object has a copy of the matched route
+          # on it when we go to evaluating, so we can just retrieve that
+          def route_name_for_padrino(request)
+            request.route_obj.original_path
+          rescue => e
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sinatra.rb

@@ -3,14 +3,18 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/agent/instrumentation/controller_instrumentation'
+require 'new_relic/agent/instrumentation/sinatra/transaction_namer'
+require 'new_relic/agent/instrumentation/sinatra/ignorer'
 
 DependencyDetection.defer do
   @name = :sinatra
 
   depends_on do
-    defined?(::Sinatra) && defined?(::Sinatra::Base) &&
+    !NewRelic::Agent.config[:disable_sinatra] &&
+      defined?(::Sinatra) && defined?(::Sinatra::Base) &&
       Sinatra::Base.private_method_defined?(:dispatch!) &&
-      Sinatra::Base.private_method_defined?(:process_route)
+      Sinatra::Base.private_method_defined?(:process_route) &&
+      Sinatra::Base.private_method_defined?(:route_eval)
   end
 
   executes do
@@ -20,12 +24,43 @@ DependencyDetection.defer do
   executes do
     ::Sinatra::Base.class_eval do
       include NewRelic::Agent::Instrumentation::Sinatra
+
       alias dispatch_without_newrelic dispatch!
       alias dispatch! dispatch_with_newrelic
+
+      alias process_route_without_newrelic process_route
+      alias process_route process_route_with_newrelic
+
+      alias route_eval_without_newrelic route_eval
+      alias route_eval route_eval_with_newrelic
+
+      register NewRelic::Agent::Instrumentation::Sinatra::Ignorer
+    end
+
+    module ::Sinatra
+      register NewRelic::Agent::Instrumentation::Sinatra::Ignorer
     end
   end
-end
 
+  executes do
+    if Sinatra::Base.respond_to?(:build)
+      # These requires are inside an executes block because they require rack, and
+      # we can't be sure that rack is available when this file is first required.
+      require 'new_relic/rack/agent_hooks'
+      require 'new_relic/rack/browser_monitoring'
+      require 'new_relic/rack/error_collector'
+
+      ::Sinatra::Base.class_eval do
+        class << self
+          alias build_without_newrelic build
+          alias build build_with_newrelic
+        end
+      end
+    else
+      ::NewRelic::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+    end
+  end
+end
 
 module NewRelic
   module Agent
@@ -35,25 +70,78 @@ module NewRelic
       # and transaction traces.
       #
       # The actions in the UI will correspond to the pattern expression used
-      # to match them.  HTTP operations are not distinguished.  Multiple matches
-      # will all be tracked as separate actions.
+      # to match them, not directly to full URL's.
       module Sinatra
         include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-        def dispatch_with_newrelic
-          # We're trying to determine the transaction name via Sinatra's
-          # process_route, but calling it here misses Sinatra's normal error handling.
-          #
-          # Relies on transaction_name to always safely return a value for us
-          txn_name = NewRelic.transaction_name(self.class.routes, @request) do |pattern, keys, conditions|
-            result = process_route(pattern, keys, conditions) do
-              pattern.source
+        # Expected method for supporting ControllerInstrumentation
+        def newrelic_request_headers
+          request.env
+        end
+
+        def self.included(clazz)
+          clazz.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def newrelic_middlewares
+            [ NewRelic::Rack::AgentHooks,
+              NewRelic::Rack::BrowserMonitoring,
+              NewRelic::Rack::ErrorCollector ]
+          end
+
+          def build_with_newrelic(*args, &block)
+            unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
+              newrelic_middlewares.each do |middleware_class|
+                try_to_use(self, middleware_class)
+              end
             end
-            result if result.class == String
+            build_without_newrelic(*args, &block)
+          end
+
+          def try_to_use(app, clazz)
+            has_middleware = app.middleware.any? { |info| info[0] == clazz }
+            app.use(clazz) unless has_middleware
+          end
+        end
+
+        # Capture last route we've seen. Will set for transaction on route_eval
+        def process_route_with_newrelic(*args, &block)
+          begin
+            env["newrelic.last_route"] = args[0]
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
+          end
+
+          process_route_without_newrelic(*args, &block)
+        end
+
+        # If a transaction name is already set, this call will tromple over it.
+        # This is intentional, as typically passing to a separate route is like
+        # an entirely separate transaction, so we pick up the new name.
+        #
+        # If we're ignored, this remains safe, since set_transaction_name
+        # care for the gating on the transaction's existence for us.
+        def route_eval_with_newrelic(*args, &block)
+          begin
+            txn_name = TransactionNamer.transaction_name_for_route(env, request)
+            ::NewRelic::Agent.set_transaction_name("#{self.class.name}/#{txn_name}") unless txn_name.nil?
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
+          end
+
+          route_eval_without_newrelic(*args, &block)
+        end
+
+        def dispatch_with_newrelic
+          if ignore_request?
+            env['newrelic.ignored'] = true
+            return dispatch_without_newrelic
           end
 
+          name = TransactionNamer.initial_transaction_name(request)
           perform_action_with_newrelic_trace(:category => :sinatra,
-                                             :name => txn_name,
+                                             :name => name,
                                              :params => @request.params) do
             dispatch_and_notice_errors_with_newrelic
           end
@@ -68,43 +156,20 @@ module NewRelic
           ::NewRelic::Agent.notice_error(env['sinatra.error']) if had_error
         end
 
-        # Define Request Header accessor for Sinatra
-        def newrelic_request_headers
-          request.env
+        def ignore_request?
+          Ignorer.should_ignore?(self, :routes)
         end
 
-        module NewRelic
-          extend self
-
-          def http_verb(request)
-            request.request_method if request.respond_to?(:request_method)
-          end
-
-          def transaction_name(routes, request)
-            name = ::NewRelic::Agent::UNKNOWN_METRIC
-            verb = http_verb(request)
-
-            Array(routes[verb]).each do |pattern, keys, conditions, block|
-              if route = yield(pattern, keys, conditions)
-                name = route
-                # it's important we short circuit here.  Otherwise we risk
-                # applying conditions from lower priority routes which can
-                # break the action.
-                break
-              end
-            end
-
-            name = name.gsub(%r{^[/^]*(.*?)[/\$\?]*$}, '\1')
-            if verb
-              name = verb + ' ' + name
-            end
+        # Overrides ControllerInstrumentation implementation
+        def ignore_apdex?
+          Ignorer.should_ignore?(self, :apdex)
+        end
 
-            name
-          rescue => e
-            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Sinatra transaction name")
-            ::NewRelic::Agent::UNKNOWN_METRIC
-          end
+        # Overrides ControllerInstrumentation implementation
+        def ignore_enduser?
+          Ignorer.should_ignore?(self, :enduser)
         end
+
       end
     end
   end

data/lib/new_relic/agent/new_relic_service.rb

@@ -146,6 +146,12 @@ module NewRelic
         invoke_remote(:agent_command_results, @agent_id, { command_id.to_s => results })
       end
 
+      # Send fine-grained analytic data to the collector.
+      def analytic_event_data(data)
+        data.collect! {|hash| [hash] }
+        invoke_remote(:analytic_event_data, @agent_id, data)
+      end
+
       # We do not compress if content is smaller than 64kb.  There are
       # problems with bugs in Ruby in some versions that expose us
       # to a risk of segfaults if we compress aggressively.

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -76,6 +76,10 @@ module NewRelic
           @out.gets("\n\n")
         end
 
+        def eof?
+          !@out.closed? && @out.eof?
+        end
+
         def after_fork_in_child
           @out.close unless @out.closed?
           write(READY_MARKER)
@@ -123,12 +127,13 @@ module NewRelic
 
               if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout)
                 now = Time.now
-                pipe = ready[0][0]
-                if pipe == wake.out
-                  pipe.read(1)
-                else
-                  merge_data_from_pipe(pipe)
+
+                ready_pipes = ready[0]
+                ready_pipes.each do |pipe|
+                  merge_data_from_pipe(pipe) unless pipe == wake.out
                 end
+
+                wake.out.read(1) if ready_pipes.include?(wake.out)
               end
 
               break unless should_keep_listening?
@@ -172,9 +177,7 @@ module NewRelic
           pipe = find_pipe_for_handle(pipe_handle)
           raw_payload = pipe.read
 
-          if raw_payload.nil?
-            pipe.close
-          elsif raw_payload && !raw_payload.empty?
+          if raw_payload && !raw_payload.empty?
             payload = unmarshal(raw_payload)
             if payload == Pipe::READY_MARKER
               pipe.after_fork_in_parent
@@ -184,6 +187,8 @@ module NewRelic
                                                      payload[:error_traces]])
             end
           end
+
+          pipe.close if pipe.eof?
         end
 
         def unmarshal(data)