wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/metric_data.rb

@@ -20,7 +20,7 @@ module NewRelic
     def original_spec
       @original_spec || @metric_spec
     end
-    
+
     # assigns a new metric spec, and retains the old metric spec as
     # @original_spec if it exists currently
     def metric_spec= new_spec
@@ -36,7 +36,7 @@ module NewRelic
     def to_json(*a)
        %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
     end
-    
+
     def to_s
       if metric_spec
         "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
@@ -44,8 +44,16 @@ module NewRelic
         "#{metric_id}: #{stats}"
       end
     end
+
     def inspect
       "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
     end
+
+    def to_collector_array(encoder=nil)
+      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
+      [ stat_key,
+        [ stats.call_count, stats.total_call_time, stats.total_exclusive_time,
+          stats.min_call_time, stats.max_call_time, stats.sum_of_squares ] ]
+    end
   end
 end

data/lib/new_relic/metric_spec.rb

@@ -10,9 +10,13 @@ class NewRelic::MetricSpec
   # Need a "zero-arg" constructor so it can be instantiated from java (using
   # jruby) for sending responses to ruby agents from the java collector.
   #
-  def initialize(metric_name = '', metric_scope = '')
+  def initialize(metric_name = '', metric_scope = nil)
     self.name = (metric_name || '') && metric_name[LENGTH_RANGE]
-    self.scope = metric_scope && metric_scope[LENGTH_RANGE]
+    if metric_scope
+      self.scope = metric_scope && metric_scope[LENGTH_RANGE]
+    else
+      self.scope = ''
+    end
   end
   
   # truncates the name and scope to the MAX_LENGTH
@@ -40,7 +44,7 @@ class NewRelic::MetricSpec
   # return a new metric spec if the given regex
   # matches the name or scope.
   def sub(pattern, replacement, apply_to_scope = true)
-    NewRelic::Control.instance.log.warn("The sub method on metric specs is deprecated") rescue nil
+    ::NewRelic::Agent.logger.warn("The sub method on metric specs is deprecated") rescue nil
     return nil if name !~ pattern &&
      (!apply_to_scope || scope.nil? || scope !~ pattern)
     new_name = name.sub(pattern, replacement)[LENGTH_RANGE]

data/lib/new_relic/noticed_error.rb

@@ -2,28 +2,51 @@
 class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
   attr_accessor :path, :timestamp, :params, :exception_class, :message
+  attr_reader :exception_id
 
   def initialize(path, data, exception, timestamp = Time.now)
-    self.path = path
-    self.params = NewRelic::NoticedError.normalize_params(data)
+    @exception_id = exception.object_id
+    @path = path
+    @params = NewRelic::NoticedError.normalize_params(data)
 
-    self.exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
+    @exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
 
     if exception.respond_to?('original_exception')
-      self.message = exception.original_exception.message.to_s
+      @message = exception.original_exception.message.to_s
     else
-      self.message = (exception || '<no message>').to_s
+      @message = (exception || '<no message>').to_s
+    end
+
+    unless @message.is_a?(String)
+      # In pre-1.9.3, Exception.new({}).to_s.class != String
+      # That is, Exception#to_s may not return a String instance if one wasn't
+      # passed in upon creation of the Exception. So, try to generate a useful
+      # String representation of the exception message, falling back to failsafe
+      @message = String(@message.inspect) rescue '<unknown message type>'
     end
 
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
-    self.message = self.message[0..4095] if self.message.length > 4096
+    @message = @message[0..4095] if @message.length > 4096
     
     # obfuscate error message if necessary
-    if NewRelic::Control.instance.fetch('high_security', false)
-      self.message = NewRelic::Agent::Database.obfuscate_sql(self.message)
+    if NewRelic::Agent.config[:high_security]
+      @message = NewRelic::Agent::Database.obfuscate_sql(@message)
     end
     
-    self.timestamp = timestamp
+    @timestamp = timestamp
+  end
+
+  def ==(other)
+    if other.respond_to?(:exception_id)
+      @exception_id == other.exception_id
+    else
+      false
+    end
+  end
+
+  def to_collector_array(encoder=nil)
+    [ (@timestamp.to_f * 1000).round, @path, @message, @exception_class,
+      @params ]
   end
 end

data/lib/new_relic/rack.rb

@@ -0,0 +1,4 @@
+module NewRelic
+  module Rack
+  end
+end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -9,17 +9,6 @@ module NewRelic::Rack
 
     # method required by Rack interface
     def call(env)
-      # Two experimental options for allowing TT capture based on http params
-      #
-      # if req.params['nr_capture_deep_tt']
-        # NewRelic::Agent::TransactionInfo.get.force_persist = true
-        # NewRelic::Agent::TransactionInfo.get.capture_deep_tt = true
-      # end
-
-      # if req.params['nr_capture_tt']
-        # NewRelic::Agent::TransactionInfo.get.force_persist = true
-      # end
-
       result = @app.call(env)   # [status, headers, response]
 
       if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(result[0], result[1])
@@ -46,29 +35,49 @@ module NewRelic::Rack
       response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
       return nil unless source
 
-      body_start = source.index("<body")
-      body_close = source.rindex("</body>")
 
-      if body_start && body_close
+      # Only scan the first 50k (roughly) then give up.
+      beginning_of_source = source[0..50_000]
+      # Don't scan for body close unless we find body start
+      if (body_start = beginning_of_source.index("<body")) && (body_close = source.rindex("</body>"))
+
         footer = NewRelic::Agent.browser_timing_footer
         header = NewRelic::Agent.browser_timing_header
 
-        if source.include?('X-UA-Compatible')
-          # put at end of header if UA-Compatible meta tag found
-          head_pos = source.index("</head>")
-        elsif head_open = source.index("<head")
+        x_ua_compatible_found = beginning_of_source.include?('X-UA-Compatible')
+
+        head_pos = if x_ua_compatible_found
+          # put at end of header if X-UA-Compatible meta tag found
+          ::NewRelic::Agent.logger.debug "Detected X-UA-Compatible meta tag. Attempting to insert RUM header at end of head."
+          beginning_of_source.index("</head>")
+        elsif head_open = beginning_of_source.index("<head")
+          ::NewRelic::Agent.logger.debug "Attempting to insert RUM header at beginning of head."
           # put at the beginning of the header
-          head_pos = source.index(">", head_open) + 1
+          beginning_of_source.index(">", head_open) + 1
         else
-          # put the header right above body start
-          head_pos = body_start
+          ::NewRelic::Agent.logger.debug "Failed to detect head tag. Attempting to insert RUM header at above body tag."
+          # otherwise put the header right above body start
+          body_start
         end
 
-        source = source[0..(head_pos-1)] + header + source[head_pos..(body_close-1)] + footer + source[body_close..-1]
-
-        headers['Content-Length'] = source.length.to_s if headers['Content-Length']
+        # check that head_pos is less than body close.  If it's not something
+        # is really weird and we should punt.
+        if head_pos && (head_pos < body_close)
+          # rebuild the source
+          source = source[0..(head_pos-1)] <<
+            header <<
+            source[head_pos..(body_close-1)] <<
+            footer <<
+            source[body_close..-1]
+        else
+          if head_pos
+            ::NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Failed to detect head tags."
+          else
+            ::NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Detected head is after detected body close."
+          end
+        end
       end
-
+      headers['Content-Length'] = source.length.to_s if headers['Content-Length']
       source
     end
   end

data/lib/new_relic/rack/developer_mode.rb

@@ -229,6 +229,9 @@ module NewRelic
         if params['d']
           @sql_segments.sort!{|a,b| b.duration <=> a.duration }
         end
+
+        sort_method = params['sort'] || :total_time
+        @profile_options = {:min_percent => 0.5, :sort_method => sort_method.to_sym}
         
         render(:show_sample)
       end

data/lib/new_relic/rack/error_collector.rb

@@ -0,0 +1,56 @@
+module NewRelic::Rack
+  class ErrorCollector
+    def initialize(app, options={})
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      request = Rack::Request.new(env)
+      if !should_ignore_error?(exception, request)
+        NewRelic::Agent.instance.error_collector.notice_error(exception,
+                                                              :uri => request.path,
+                                                          :referer => request.referer,
+                                                   :request_params => request.params)
+      end
+      raise exception
+    end
+
+    def should_ignore_error?(error, request)
+      NewRelic::Agent.instance.error_collector.error_is_ignored?(error) ||
+        ignored_in_controller?(error, request)
+    end
+
+    def ignored_in_controller?(exception, request)
+      if request.env['action_dispatch.request.parameters']
+        ignore_actions = newrelic_ignore_for_controller(request.env['action_dispatch.request.parameters']['controller'])
+        action_name = request.env['action_dispatch.request.parameters']['action']
+
+        case ignore_actions
+        when nil; false
+        when Hash
+          only_actions = Array(ignore_actions[:only])
+          except_actions = Array(ignore_actions[:except])
+          only_actions.include?(action_name.to_sym) ||
+            (except_actions.any? &&
+             !except_actions.include?(action_name.to_sym))
+        else
+          true
+        end
+      end
+    end
+
+    def newrelic_ignore_for_controller(controller_name)
+      if controller_name
+        controller_constant_name = (controller_name + "_controller").camelize
+        if Object.const_defined?(controller_constant_name)
+          controller = controller_constant_name.constantize
+          controller.instance_variable_get(:@do_not_trace)
+        end
+      end
+    rescue NameError
+      nil
+    end
+  end
+end

data/lib/new_relic/stats.rb

@@ -219,13 +219,15 @@ module NewRelic
       super
     end
 
-    def to_json(*a)
-      {'call_count' => call_count,
-        'min_call_time' => min_call_time,
-        'max_call_time' => max_call_time,
-        'total_call_time' => total_call_time,
-        'total_exclusive_time' => total_exclusive_time,
-        'sum_of_squares' => sum_of_squares}.to_json(*a)
+    def to_json(*_)
+      {
+        'call_count'           => call_count.to_i,
+        'min_call_time'        => min_call_time.to_f,
+        'max_call_time'        => max_call_time.to_f,
+        'total_call_time'      => total_call_time.to_f,
+        'total_exclusive_time' => total_exclusive_time.to_f,
+        'sum_of_squares'       => sum_of_squares.to_f
+      }.to_json(*_)
     end
 
 

data/lib/new_relic/transaction_sample.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 require 'new_relic/transaction_sample/segment'
 require 'new_relic/transaction_sample/summary_segment'
 require 'new_relic/transaction_sample/fake_segment'
@@ -51,15 +53,20 @@ module NewRelic
       @start_time - @@start_time.to_f
     end
 
-    # Used in the server only
-    def to_json(options = {}) #:nodoc:
-      map = {:sample_id => @sample_id,
-        :start_time => @start_time,
-        :root_segment => @root_segment}
-      if @params && !@params.empty?
-        map[:params] = @params
-      end
-      map.to_json
+    def to_json
+      JSON.dump(self.to_array)
+    end
+
+    def to_array
+      [ @start_time.to_f, @params[:request_params], @params[:custom_params],
+        @root_segment.to_array ]
+    end
+
+    def to_collector_array(encoder)
+      trace_tree = encoder.encode(self.to_array)
+      [ Helper.time_to_millis(@start_time), Helper.time_to_millis(duration),
+        @params[:path], @params[:uri], trace_tree, @guid, nil,
+        !!@force_persist ]
     end
 
     def start_time
@@ -134,10 +141,10 @@ module NewRelic
       regex = Regexp.new(regex)
 
       sample = TransactionSample.new(@start_time, sample_id)
-      
+
       sample.params = params.dup
       sample.params[:segment_count] = 0
-      
+
       delta = build_segment_with_omissions(sample, 0.0, @root_segment, sample.root_segment, regex)
       sample.root_segment.end_trace(@root_segment.exit_timestamp - delta)
       sample.profile = self.profile
@@ -159,11 +166,7 @@ module NewRelic
       sample.guid = self.guid
       sample.force_persist = self.force_persist if self.force_persist
 
-      begin
-        build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
-      ensure
-        NewRelic::Agent::Database.close_connections
-      end
+      build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
 
       sample.root_segment.end_trace(@root_segment.exit_timestamp)
       sample
@@ -175,8 +178,6 @@ module NewRelic
 
   private
 
-
-
     HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
     # generate a random 64 bit uuid
     def generate_guid

data/lib/new_relic/transaction_sample/segment.rb

@@ -1,4 +1,5 @@
 require 'new_relic/transaction_sample'
+
 module NewRelic
   class TransactionSample
     class Segment
@@ -15,13 +16,13 @@ module NewRelic
         @metric_name = metric_name || '<unknown>'
         @segment_id = segment_id || object_id
       end
-      
+
       # sets the final timestamp on a segment to indicate the exit
       # point of the segment
       def end_trace(timestamp)
         @exit_timestamp = timestamp
       end
-      
+
       def add_called_segment(s)
         @called_segments ||= []
         @called_segments << s
@@ -32,18 +33,15 @@ module NewRelic
         to_debug_str(0)
       end
 
-      def to_json(options={})
-        hash = {
-          :entry_timestamp => @entry_timestamp,
-          :exit_timestamp => @exit_timestamp,
-          :metric_name => @metric_name,
-          :segment_id => @segment_id,
-        }
-
-        hash[:called_segments] = called_segments if !called_segments.empty?
-        hash[:params] = @params if @params && !@params.empty?
+      def to_array
+        [ (@entry_timestamp.to_f * 1000).round,
+          (@exit_timestamp.to_f * 1000).round,
+          @metric_name, (@params || {}) ] +
+          [ (@called_segments ? @called_segments.map{|s| s.to_array} : []) ]
+      end
 
-        hash.to_json
+      def to_json
+        JSON.dump(self.to_array)
       end
 
       def path_string
@@ -97,13 +95,13 @@ module NewRelic
         end
         d
       end
-      
+
       def count_segments
         count = 1
         called_segments.each { | seg | count  += seg.count_segments }
         count
       end
-      
+
       # Walk through the tree and truncate the segments in a
       # depth-first manner
       def truncate(max)

data/lib/new_relic/version.rb

@@ -1,10 +1,26 @@
 #!/usr/bin/ruby
+
 module NewRelic
   module VERSION #:nodoc:
+    def self.parse_build_from_gemspec(path)
+      if File.exist?(path)
+        version_string = if Kernel.const_defined?(:Gem)
+          spec = Gem::Specification.load(path)
+          spec.version.to_s if spec
+        else
+          md = File.read(path).match(/s\.version\s*=\s*"(.*)"/)
+          md[1] if md
+        end
+        version_string && version_string.split('.', 4)[3]
+      end
+    end
+
+    GEMSPEC_PATH = File.join(File.dirname(__FILE__), '..', '..', 'newrelic_rpm.gemspec')
     MAJOR = 3
-    MINOR = 3
-    TINY  = 4
-    BUILD = 1 # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    MINOR = 5
+    TINY  = 5
+    BUILD = parse_build_from_gemspec(GEMSPEC_PATH)
+
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end