newrelic_rpm 3.9.1.236 → 3.9.2.239

data/lib/new_relic/agent/instrumentation/merb/controller.rb

@@ -21,17 +21,6 @@ DependencyDetection.defer do
     Merb::Controller.class_eval do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-      class_inheritable_accessor :do_not_trace
-      class_inheritable_accessor :ignore_apdex
-
-      def self.newrelic_write_attr(attr_name, value) # :nodoc:
-        self.send "#{attr_name}=", attr_name, value
-      end
-
-      def self.newrelic_read_attr(attr_name) # :nodoc:
-        self.send attr_name
-      end
-
       # determine the path that is used in the metric name for
       # the called controller action
       def newrelic_metric_path

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

@@ -50,7 +50,7 @@ module NewRelic
           state = NewRelic::Agent::TransactionState.tl_get
 
           begin
-            txn = Transaction.start(state, category, opts)
+            Transaction.start(state, category, opts)
             if target == self
               traced_call(env)
             else

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -101,14 +101,6 @@ DependencyDetection.defer do
       alias_method :perform_action, :perform_action_with_newrelic_trace
       private :perform_action
 
-      def self.newrelic_write_attr(attr_name, value) # :nodoc:
-        write_inheritable_attribute(attr_name, value)
-      end
-
-      def self.newrelic_read_attr(attr_name) # :nodoc:
-        read_inheritable_attribute(attr_name)
-      end
-
       # determine the path that is used in the metric name for
       # the called controller action
       def newrelic_metric_path(action_name_override = nil)

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -7,14 +7,6 @@ module NewRelic
     module Instrumentation
       module Rails3
         module ActionController
-          def self.newrelic_write_attr(attr_name, value) # :nodoc:
-            write_inheritable_attribute(attr_name, value)
-          end
-
-          def self.newrelic_read_attr(attr_name) # :nodoc:
-            read_inheritable_attribute(attr_name)
-          end
-
           # determine the path that is used in the metric name for
           # the called controller action
           def newrelic_metric_path(action_name_override = nil)
@@ -28,7 +20,7 @@ module NewRelic
 
           def process_action(*args) #THREAD_LOCAL_ACCESS
             # skip instrumentation if we are in an ignored action
-            if _is_filtered?('do_not_trace')
+            if _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
               txn = NewRelic::Agent::Transaction.tl_current
               txn.ignore! if txn
               NewRelic::Agent.disable_all_tracing do

data/lib/new_relic/agent/instrumentation/rails4/action_controller.rb

@@ -3,23 +3,6 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 require 'new_relic/agent/instrumentation/action_controller_subscriber'
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Rails4
-        module ActionController
-          def self.newrelic_write_attr(attr_name, value) # :nodoc:
-            write_inheritable_attribute(attr_name, value)
-          end
-
-          def self.newrelic_read_attr(attr_name) # :nodoc:
-            read_inheritable_attribute(attr_name)
-          end
-        end
-      end
-    end
-  end
-end
 
 DependencyDetection.defer do
   @name = :rails4_controller
@@ -39,7 +22,6 @@ DependencyDetection.defer do
   executes do
     class ActionController::Base
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      include NewRelic::Agent::Instrumentation::Rails4::ActionController
     end
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
       .subscribe(/^process_action.action_controller$/)

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

@@ -6,7 +6,7 @@ DependencyDetection.defer do
   named :rubyprof
 
   depends_on do
-    defined?(::RubyProf)
+    defined?(::RubyProf) && defined?(::NewRelic::Rack::DeveloperMode) && ::NewRelic::Agent.config[:developer_mode]
   end
 
   executes do

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

@@ -45,7 +45,7 @@ DependencyDetection.defer do
 
     class Sidekiq::Extensions::DelayedClass
       def newrelic_trace_args(msg, queue)
-        (target, method_name, args) = YAML.load(msg['args'][0])
+        (target, method_name, _args) = YAML.load(msg['args'][0])
         {
           :name => method_name,
           :class_name => target.name,

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

@@ -144,14 +144,25 @@ module NewRelic
             return dispatch_without_newrelic
           end
 
+          request_params = get_request_params
+
           name = TransactionNamer.initial_transaction_name(request)
           perform_action_with_newrelic_trace(:category => :sinatra,
                                              :name => name,
-                                             :params => @request.params) do
+                                             :params => request_params) do
             dispatch_and_notice_errors_with_newrelic
           end
         end
 
+        def get_request_params
+          begin
+            @request.params
+          rescue => e
+            NewRelic::Agent.logger.debug("Failed to get params from Rack request.", e)
+            nil
+          end
+        end
+
         def dispatch_and_notice_errors_with_newrelic
           dispatch_without_newrelic
         ensure

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

@@ -46,7 +46,7 @@ module NewRelic
           # 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
+          rescue
             nil
           end
         end

data/lib/new_relic/agent/method_tracer.rb

@@ -380,30 +380,18 @@ module NewRelic
         end
         include AddMethodTracer
 
-
-
         # Add a method tracer to the specified method.
         #
-        # === Options
-        #
-        # * <tt>:push_scope => false</tt> specifies this method tracer should not
-        #   keep track of the caller; it will not show up in controller breakdown
-        #   pie charts.
-        # * <tt>:metric => false</tt> specifies that no metric will be recorded.
-        #   Instead the call will show up in transaction traces as well as traces
-        #   shown in Developer Mode.
-        #
-        # === Uncommon Options
-        #
-        # * <tt>:code_header</tt> and <tt>:code_footer</tt> specify ruby code that
-        #   is inserted into the tracer before and after the call.
+        # By default, this will cause invocations of the traced method to be
+        # recorded in transaction traces, and in a metric named after the class
+        # and method. It will also make the method show up in transaction-level
+        # breakdown charts and tables.
         #
         # === Overriding the metric name
         #
-        # +metric_name_code+ is a string that is eval'd to get the
-        # name of the metric associated with the call, so if you want to
-        # use interpolaion evaluated at call time, then single quote
-        # the value like this:
+        # +metric_name_code+ is a string that is eval'd to get the name of the
+        # metric associated with the call, so if you want to use interpolation
+        # evaluated at call time, then single quote the value like this:
         #
         #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo'
         #
@@ -412,30 +400,36 @@ module NewRelic
         #
         # If not provided, the metric name will be <tt>Custom/ClassName/method_name</tt>.
         #
-        # === Examples
-        #
-        # Instrument +foo+ only for custom views--will not show up in transaction traces or caller breakdown graphs:
-        #
-        #     add_method_tracer :foo, :push_scope => false
-        #
-        # Instrument +foo+ just for transaction traces only:
-        #
-        #     add_method_tracer :foo, :metric => false
-        #
-        # Instrument +foo+ so it shows up in transaction traces and caller breakdown graphs
-        # for actions:
-        #
-        #     add_method_tracer :foo
+        # @param [Symbol] method_name the name of the method to trace
+        # @param [String] metric_name_code the metric name to record calls to
+        #   the traced method under. This may be either a static string, or Ruby
+        #   code to be evaluated at call-time in order to determine the metric
+        #   name dynamically.
+        # @param [Hash] options additional options controlling how the method is
+        #   traced.
+        # @option options [Boolean] :push_scope (true) If false, the traced method will
+        #   not appear in transaction traces or breakdown charts, and it will
+        #   only be visible in custom dashboards.
+        # @option options [Boolean] :metric (true) If false, the traced method will
+        #   only appear in transaction traces, but no metrics will be recorded
+        #   for it.
+        # @option options [String] :code_header ('') Ruby code to be inserted and run
+        #   before the tracer begins timing.
+        # @option options [String] :code_footer ('') Ruby code to be inserted and run
+        #   after the tracer stops timing.
         #
-        # which is equivalent to:
+        # @example
+        #   add_method_tracer :foo
         #
-        #     add_method_tracer :foo, 'Custom/#{self.class.name}/foo', :push_scope => true, :metric => true
+        #   # With a custom metric name
+        #   add_method_tracer :foo, 'Custom/#{self.class.name}/foo'
         #
-        # Instrument the class method +foo+ with the metric name 'Custom/People/fetch':
+        #   # Instrument foo only for custom dashboards (not in transaction
+        #   # traces or breakdown charts)
+        #   add_method_tracer :foo, 'Custom/foo', :push_scope => false
         #
-        #     class << self
-        #       add_method_tracer :foo, 'Custom/People/fetch'
-        #     end
+        #   # Instrument foo in transaction traces only
+        #   add_method_tracer :foo, 'Custom/foo', :metric => false
         #
         # @api public
         #

data/lib/new_relic/agent/new_relic_service.rb

@@ -4,6 +4,10 @@
 
 require 'zlib'
 require 'new_relic/agent/audit_logger'
+require 'new_relic/agent/new_relic_service/encoders'
+require 'new_relic/agent/new_relic_service/marshaller'
+require 'new_relic/agent/new_relic_service/json_marshaller'
+require 'new_relic/agent/new_relic_service/pruby_marshaller'
 
 module NewRelic
   module Agent
@@ -46,12 +50,12 @@ module NewRelic
         Agent.config.register_callback(:marshaller) do |marshaller|
           begin
             if marshaller == 'json'
-              require 'json'
               @marshaller = JsonMarshaller.new
             else
               @marshaller = PrubyMarshaller.new
             end
           rescue LoadError
+            ::NewRelic::Agent.logger.warn("JSON marshaller requested, but the 'json' gem was not available, falling back to pruby. This will not be supported in future versions of the agent.")
             @marshaller = PrubyMarshaller.new
           end
         end
@@ -181,28 +185,42 @@ module NewRelic
       def session(&block)
         raise ArgumentError, "#{self.class}#shared_connection must be passed a block" unless block_given?
 
-        # Immediately open a TCP connection to the server and leave it open for
-        # multiple requests.
         begin
           t0 = Time.now
-          @in_session = true
-          establish_shared_connection
-          block.call
+          if NewRelic::Agent.config[:aggressive_keepalive]
+            session_with_keepalive(&block)
+          else
+            session_without_keepalive(&block)
+          end
         rescue Timeout::Error
           elapsed = Time.now - t0
           ::NewRelic::Agent.logger.warn "Timed out opening connection to collector after #{elapsed} seconds. If this problem persists, please see http://status.newrelic.com"
           raise
+        end
+      end
+
+      def session_with_keepalive(&block)
+        establish_shared_connection
+        block.call
+      end
+
+      def session_without_keepalive(&block)
+        begin
+          establish_shared_connection
+          block.call
         ensure
-          @in_session = false
           close_shared_connection
         end
       end
 
       def establish_shared_connection
-        connection = create_http_connection
-        NewRelic::Agent.logger.debug("Opening shared TCP connection to #{connection.address}:#{connection.port}")
-        NewRelic::TimerLib.timeout(@request_timeout) { connection.start }
-        @shared_tcp_connection = connection
+        unless @shared_tcp_connection
+          connection = create_http_connection
+          NewRelic::Agent.logger.debug("Opening shared TCP connection to #{connection.address}:#{connection.port}")
+          NewRelic::TimerLib.timeout(@request_timeout) { connection.start }
+          @shared_tcp_connection = connection
+        end
+        @shared_tcp_connection
       end
 
       def close_shared_connection
@@ -217,9 +235,7 @@ module NewRelic
       # We'll reuse the same handle for cases where we're using keep-alive, or
       # otherwise create a new one.
       def http_connection
-        (@shared_tcp_connection ||
-          (@in_session && establish_shared_connection) ||
-          create_http_connection)
+        @shared_tcp_connection || create_http_connection
       end
 
       # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
@@ -244,6 +260,11 @@ module NewRelic
             raise UnrecoverableAgentException.new(msg)
           end
         end
+
+        if http.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
+          http.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
+        end
+
         ::NewRelic::Agent.logger.debug("Created net/http handle to #{http.address}:#{http.port}")
         http
       end
@@ -419,150 +440,8 @@ module NewRelic
         "NewRelic-RubyAgent/#{NewRelic::VERSION::STRING} #{ruby_description}#{zlib_version}"
       end
 
-      module Encoders
-        module Identity
-          def self.encode(data)
-            data
-          end
-        end
-
-        module Compressed
-          def self.encode(data)
-            Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
-          end
-        end
-
-        module Base64CompressedJSON
-          def self.encode(data)
-            json = ::NewRelic::JSONWrapper.dump(data,
-              :normalize => Agent.config[:normalize_json_string_encodings])
-            Base64.encode64(Compressed.encode(json))
-          end
-        end
-      end
-
       # Used to wrap errors reported to agent by the collector
       class CollectorError < StandardError; end
-
-      class Marshaller
-        def parsed_error(error)
-          error_class = error['error_type'].split('::') \
-            .inject(Module) {|mod,const| mod.const_get(const) }
-          error_class.new(error['message'])
-        rescue NameError
-          CollectorError.new("#{error['error_type']}: #{error['message']}")
-        end
-
-        def prepare(data, options={})
-          encoder = options[:encoder] || default_encoder
-          if data.respond_to?(:to_collector_array)
-            data.to_collector_array(encoder)
-          elsif data.kind_of?(Array)
-            data.map { |element| prepare(element, options) }
-          else
-            data
-          end
-        end
-
-        def default_encoder
-          Encoders::Identity
-        end
-
-        def self.human_readable?
-          false
-        end
-
-        protected
-
-        def return_value(data)
-          if data.respond_to?(:has_key?)
-            if data.has_key?('exception')
-              raise parsed_error(data['exception'])
-            elsif data.has_key?('return_value')
-              return data['return_value']
-            end
-          end
-          ::NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
-          nil
-        end
-      end
-
-      # Primitive Ruby Object Notation which complies JSON format data strutures
-      class PrubyMarshaller < Marshaller
-        def initialize
-          ::NewRelic::Agent.logger.debug 'Using Pruby marshaller'
-          warn_for_pruby_deprecation
-        end
-
-        def warn_for_pruby_deprecation
-          if !NewRelic::LanguageSupport.stdlib_json_usable? && !defined?(::JSON)
-            NewRelic::Agent.logger.warn("Upcoming versions of the Ruby agent running on Ruby 1.8.7 will require the 'json' gem. To avoid interuption in reporting, please update your Gemfile. See http://docs.newrelic.com/docs/ruby/ruby-1.8.7-support for more information.")
-          end
-        end
-
-        def dump(ruby, opts={})
-          NewRelic::LanguageSupport.with_cautious_gc do
-            Marshal.dump(prepare(ruby, opts))
-          end
-        rescue => e
-          ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} when marshalling #{ruby.inspect}")
-          raise
-        end
-
-        def load(data)
-          return unless data && data != ''
-          NewRelic::LanguageSupport.with_cautious_gc do
-            return_value(Marshal.load(data))
-          end
-        rescue
-          ::NewRelic::Agent.logger.debug "Error encountered loading collector response: #{data}"
-          raise
-        end
-
-        def format
-          'pruby'
-        end
-
-        def self.is_supported?
-          true
-        end
-      end
-
-      # Marshal collector protocol with JSON when available
-      class JsonMarshaller < Marshaller
-        def initialize
-          ::NewRelic::Agent.logger.debug 'Using JSON marshaller'
-        end
-
-        def dump(ruby, opts={})
-          prepared = prepare(ruby, opts)
-          NewRelic::JSONWrapper.dump(prepared,
-            :normalize => Agent.config[:normalize_json_string_encodings])
-        end
-
-        def load(data)
-          return_value(NewRelic::JSONWrapper.load(data)) if data && data != ''
-        rescue => e
-          ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
-          raise
-        end
-
-        def default_encoder
-          Encoders::Base64CompressedJSON
-        end
-
-        def format
-          'json'
-        end
-
-        def self.is_supported?
-          NewRelic::JSONWrapper.usable_for_collector_serialization?
-        end
-
-        def self.human_readable?
-          true # for some definitions of 'human'
-        end
-      end
     end
   end
 end