newrelic_rpm 3.9.4.245 → 3.9.5.251

data/lib/new_relic/agent/rules_engine/segment_terms_rule.rb

@@ -0,0 +1,48 @@
+# 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
+    class RulesEngine
+      class SegmentTermsRule
+        SEGMENT_PLACEHOLDER               = '*'.freeze
+        ADJACENT_PLACEHOLDERS_REGEX       = %r{((?:^|/)\*)(?:/\*)*}.freeze
+        ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
+
+        attr_reader :prefix, :terms
+
+        def initialize(options)
+          @prefix          = options['prefix']
+          @terms           = options['terms']
+          @trim_range      = (@prefix.size..-1)
+        end
+
+        def terminal?
+          true
+        end
+
+        def matches?(string)
+          string.start_with?(@prefix)
+        end
+
+        def apply(string)
+          rest          = string[@trim_range]
+          leading_slash = rest.slice!(LEADING_SLASH_REGEX)
+
+          segments = rest.split(SEGMENT_SEPARATOR)
+          segments.map! { |s| @terms.include?(s) ? s : SEGMENT_PLACEHOLDER }
+          transformed_suffix = collapse_adjacent_placeholder_segments(segments)
+
+          "#{@prefix}#{leading_slash}#{transformed_suffix}"
+        end
+
+        def collapse_adjacent_placeholder_segments(segments)
+          joined = segments.join(SEGMENT_SEPARATOR)
+          joined.gsub!(ADJACENT_PLACEHOLDERS_REGEX, ADJACENT_PLACEHOLDERS_REPLACEMENT)
+          joined
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/samplers/cpu_sampler.rb

@@ -13,7 +13,7 @@ module NewRelic
         named :cpu
 
         def initialize
-          @processor_count = NewRelic::Agent::SystemInfo.processor_count
+          @processor_count = NewRelic::Agent::SystemInfo.num_logical_processors
           if @processor_count.nil?
             NewRelic::Agent.logger.warn("Failed to determine processor count, assuming 1")
             @processor_count = 1

data/lib/new_relic/agent/sql_sampler.rb

@@ -39,6 +39,8 @@ module NewRelic
       # this is for unit tests only
       attr_reader :sql_traces
 
+      MAX_SAMPLES = 10
+
       def initialize
         @sql_traces = {}
 
@@ -82,27 +84,55 @@ module NewRelic
         data.set_transaction_name(name)
         if data.sql_data.size > 0
           @samples_lock.synchronize do
-            ::NewRelic::Agent.logger.debug "Harvesting #{data.sql_data.size} slow transaction sql statement(s)"
-            harvest_slow_sql data
+            ::NewRelic::Agent.logger.debug "Examining #{data.sql_data.size} slow transaction sql statement(s)"
+            save_slow_sql data
           end
         end
       end
 
       # this should always be called under the @samples_lock
-      def harvest_slow_sql(transaction_sql_data)
+      def save_slow_sql(transaction_sql_data)
+        path = transaction_sql_data.path
+        uri  = transaction_sql_data.uri
+
         transaction_sql_data.sql_data.each do |sql_item|
           normalized_sql = sql_item.normalize
           sql_trace = @sql_traces[normalized_sql]
           if sql_trace
-            sql_trace.aggregate(sql_item, transaction_sql_data.path,
-                                transaction_sql_data.uri)
+            sql_trace.aggregate(sql_item, path, uri)
           else
-            @sql_traces[normalized_sql] = SqlTrace.new(normalized_sql,
-                sql_item, transaction_sql_data.path, transaction_sql_data.uri)
+            if has_room?
+              sql_trace = SqlTrace.new(normalized_sql, sql_item, path, uri)
+            elsif should_add_trace?(sql_item)
+              remove_shortest_trace
+              sql_trace = SqlTrace.new(normalized_sql, sql_item, path, uri)
+            end
+
+            if sql_trace
+              @sql_traces[normalized_sql] = sql_trace
+            end
           end
         end
       end
 
+      # this should always be called under the @samples_lock
+      def should_add_trace?(sql_item)
+        @sql_traces.any? do |(_, existing_trace)|
+          existing_trace.max_call_time < sql_item.duration
+        end
+      end
+
+      # this should always be called under the @samples_lock
+      def has_room?
+        @sql_traces.size < MAX_SAMPLES
+      end
+
+      # this should always be called under the @samples_lock
+      def remove_shortest_trace
+        shortest_key, _ = @sql_traces.min_by { |(_, trace)| trace.max_call_time }
+        @sql_traces.delete(shortest_key)
+      end
+
       # Records an SQL query, potentially creating a new slow SQL trace, or
       # aggregating the query into an existing slow SQL trace.
       #
@@ -150,12 +180,11 @@ module NewRelic
       def harvest!
         return [] unless enabled?
 
-        result = []
+        slowest = []
         @samples_lock.synchronize do
-          result = @sql_traces.values
+          slowest = @sql_traces.values
           @sql_traces = {}
         end
-        slowest = result.sort{|a,b| b.max_call_time <=> a.max_call_time}[0,10]
         slowest.each {|trace| trace.prepare_to_send }
         slowest
       end

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -183,6 +183,7 @@ module NewRelic
         def merge!(other_stats_hash)
           with_stats_lock do
             @stats_hash.merge!(other_stats_hash)
+            @stats_hash
           end
         end
 

data/lib/new_relic/agent/stats_engine/stats_hash.rb

@@ -10,6 +10,11 @@
 # Missing keys will be automatically created as empty NewRelic::Agent::Stats
 # instances, so use has_key? explicitly to check for key existence.
 #
+# Note that instances of this class are intended to be append-only with respect
+# to new metrics. That is, you should not attempt to *remove* an entry after it
+# has been added, only update it (create a new instance if you need to start
+# over with a blank slate).
+#
 # This class makes no provisions for safe usage from multiple threads, such
 # measures should be externally provided.
 
@@ -18,6 +23,7 @@ require 'new_relic/agent/internal_agent_error'
 module NewRelic
   module Agent
     class StatsHash < ::Hash
+
       attr_accessor :started_at, :harvested_at
 
       def initialize(started_at=Time.now)
@@ -68,24 +74,12 @@ module NewRelic
         end
       end
 
-      class StatsMergerError < NewRelic::Agent::InternalAgentError
-        def initialize(key, destination, source, original_exception)
-          super("Failure when merging stats '#{key}'. In Hash: #{destination.inspect_full}. Merging: #{source.inspect_full}. Original exception: #{original_exception.class} #{original_exception.message}")
-          set_backtrace(original_exception.backtrace)
-        end
-      end
-
       def merge!(other)
         if other.is_a?(StatsHash) && other.started_at < @started_at
           @started_at = other.started_at
         end
         other.each do |key, val|
-          begin
-            merge_or_insert(key, val)
-          rescue => err
-            NewRelic::Agent.instance.error_collector. \
-              notice_agent_error(StatsMergerError.new(key, self.fetch(key, nil), val, err))
-          end
+          merge_or_insert(key, val)
         end
         self
       end

data/lib/new_relic/agent/system_info.rb

@@ -16,20 +16,106 @@ module NewRelic
         RbConfig::CONFIG['target_os']
       end
 
-      def self.processor_count
-        case ruby_os_identifier
-        when /darwin/, /freebsd/
-          `sysctl -n hw.ncpu`.to_i
-        when /linux/
-          cpuinfo = proc_try_read('/proc/cpuinfo')
-          return unless cpuinfo
-          processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
-          processors == 0 ? nil : processors
+      def self.clear_processor_info
+        @processor_info = nil
+      end
+
+      def self.get_processor_info
+        if @processor_info.nil?
+          case ruby_os_identifier
+
+          when /darwin/, /freebsd/
+            @processor_info = {
+              :num_physical_packages  => `sysctl -n hw.packages`.to_i,
+              :num_physical_cores     => `sysctl -n hw.physicalcpu_max`.to_i,
+              :num_logical_processors => `sysctl -n hw.logicalcpu_max`.to_i
+            }
+            # in case those don't work, try backup values
+            if @processor_info[:num_physical_cores] <= 0
+              @processor_info[:num_physical_cores] = `sysctl -n hw.physicalcpu`.to_i
+            end
+            if @processor_info[:num_logical_processors] <= 0
+              @processor_info[:num_logical_processors] = `sysctl -n hw.logicalcpu`.to_i
+            end
+            if @processor_info[:num_logical_processors] <= 0
+              @processor_info[:num_logical_processors] = `sysctl -n hw.ncpu`.to_i
+            end
+            if @processor_info[:num_logical_processors] <= 0
+              @processor_info[:num_logical_processors] = `sysctl -n hw.availcpu`.to_i
+            end
+            if @processor_info[:num_logical_processors] <= 0
+              @processor_info[:num_logical_processors] = `sysctl -n hw.activecpu`.to_i
+            end
+
+          when /linux/
+            cpuinfo = proc_try_read('/proc/cpuinfo')
+            @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : {}
+          end
+
+          # give nils for obviously wrong values
+          @processor_info.keys.each do |key|
+            @processor_info[key] = nil if @processor_info[key] <= 0
+          end
         end
+
+        @processor_info
       rescue
-        nil
+        {}
       end
 
+      def self.parse_cpuinfo(cpuinfo)
+        # Build a hash of the form
+        #   { [phys_id, core_id] => num_logical_processors_on_this_core }
+        cores = Hash.new(0)
+        phys_id = core_id = nil
+
+        total_processors = 0
+
+        cpuinfo.split("\n").map(&:strip).each do |line|
+          case line
+          when /^processor\s*:/
+            cores[[phys_id, core_id]] += 1 if phys_id && core_id
+            phys_id = core_id = nil # reset these values
+            total_processors += 1
+          when /^physical id\s*:(.*)/
+            phys_id = $1.strip.to_i
+          when /^core id\s*:(.*)/
+            core_id = $1.strip.to_i
+          end
+        end
+        cores[[phys_id, core_id]] += 1 if phys_id && core_id
+
+        num_physical_packages  = cores.keys.map(&:first).uniq.size
+        num_physical_cores     = cores.size
+        num_logical_processors = cores.values.reduce(0,:+)
+
+        if num_physical_cores == 0
+          num_logical_processors = total_processors
+
+          if total_processors == 1
+            # Some older, single-core processors might not list ids,
+            # so we'll just mark them all 1.
+            num_physical_packages = 1
+            num_physical_cores    = 1
+          else
+            # We have no way of knowing how many packages or cores
+            # we have, even though we know how many processors there are.
+            num_physical_packages = nil
+            num_physical_cores    = nil
+          end
+        end
+
+        {
+          :num_physical_packages  => num_physical_packages,
+          :num_physical_cores     => num_physical_cores,
+          :num_logical_processors => num_logical_processors
+        }
+      end
+
+      def self.num_physical_packages ; get_processor_info[:num_physical_packages ] end
+      def self.num_physical_cores    ; get_processor_info[:num_physical_cores    ] end
+      def self.num_logical_processors; get_processor_info[:num_logical_processors] end
+
       def self.processor_arch
         RbConfig::CONFIG['target_cpu']
       end

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -13,7 +13,10 @@ module NewRelic
             begin
               blk.call
             rescue => e
-              ::NewRelic::Agent.logger.debug("Thread #{label} exited with error", e)
+              ::NewRelic::Agent.logger.error("Thread #{label} exited with error", e)
+            rescue Exception => e
+              ::NewRelic::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interupt.", e)
+              raise
             ensure
               ::NewRelic::Agent.logger.debug("Exiting New Relic thread: #{label}")
             end

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -5,103 +5,113 @@
 module NewRelic
   module Agent
     module Threading
+      MAX_THREAD_PROFILE_DEPTH = 500
 
-      class BacktraceNode
-        attr_reader :file, :method, :line_no, :children, :raw_line
-        attr_accessor :runnable_count, :depth
-
-        def initialize(line)
-          if line
-            @raw_line = line
-            @root = false
-          else
-            @root = true
-          end
+      class BacktraceBase
+        attr_reader :children
 
+        def initialize
           @children = []
-          @runnable_count = 0
-          @depth = 0
+          @depth    = 0
         end
 
-        def root?
-          @root
+        def add_child_unless_present(child)
+          child.depth = @depth + 1
+          @children << child unless @children.include? child
         end
 
-        def empty?
-          root? && @children.empty?
+        def add_child(child)
+          child.depth = @depth + 1
+          @children << child
         end
 
-        def find(raw_line)
+        def find_child(raw_line)
           @children.find { |child| child.raw_line == raw_line }
         end
+      end
+
+
+      class BacktraceRoot < BacktraceBase
+        attr_reader :flattened
+
+        def initialize
+          super
+          @flattened = []
+        end
 
         def ==(other)
-          (
-            (root? && other.root? || @raw_line == other.raw_line) &&
-            (
-              @depth == other.depth &&
-              @runnable_count == other.runnable_count
-            )
-          )
+          true # all roots are at the same depth and have no raw_line
         end
 
-        def total_count
-          @runnable_count
+        def as_array
+          @children.map { |c| c.as_array }.compact
         end
 
         def aggregate(backtrace)
           current = self
 
+          depth = 0
           backtrace.reverse_each do |frame|
-            existing_node = current.find(frame)
+            break if depth >= MAX_THREAD_PROFILE_DEPTH
+
+            existing_node = current.find_child(frame)
             if existing_node
               node = existing_node
             else
               node = Threading::BacktraceNode.new(frame)
-              current.add_child_unless_present(node)
+              current.add_child(node)
+              @flattened << node
             end
 
             node.runnable_count += 1
             current = node
+            depth += 1
           end
         end
 
-        # Descending order on count, ascending on depth of nodes
-        def <=>(other)
-          [-runnable_count, depth] <=> [-other.runnable_count, other.depth]
+        def dump_string
+          result = "#<BacktraceRoot:#{object_id}>"
+          child_results = @children.map { |c| c.dump_string(2) }.join("\n")
+          result << "\n" unless child_results.empty?
+          result << child_results
+        end
+      end
+
+
+      class BacktraceNode < BacktraceBase
+        attr_reader   :file, :method, :line_no, :raw_line, :as_array
+        attr_accessor :runnable_count, :depth
+
+        def initialize(line)
+          super()
+          @raw_line = line
+          @children = []
+          @runnable_count = 0
+        end
+
+        def ==(other)
+          (
+            @raw_line       == other.raw_line &&
+            @depth          == other.depth    &&
+            @runnable_count == other.runnable_count
+          )
         end
 
-        def flatten
-          initial = self.root? ? [] : [self]
-          @children.inject(initial) { |all, child| all.concat(child.flatten) }
+        def mark_for_array_conversion
+          @as_array = []
         end
 
         include NewRelic::Coerce
 
-        def to_array
-          child_arrays = @children.map { |c| c.to_array }
-          return child_arrays if root?
-          file, method, line = parse_backtrace_frame(@raw_line)
-          [
-            [
-              string(file),
-              string(method),
-              int(line)
-            ],
-            int(@runnable_count),
-            0,
-            child_arrays
-          ]
-        end
+        def complete_array_conversion
+          child_arrays = @children.map { |c| c.as_array }.compact
 
-        def add_child_unless_present(child)
-          child.depth = @depth + 1
-          @children << child unless @children.include? child
-        end
+          file, method, line = parse_backtrace_frame(@raw_line)
 
-        def prune!(targets)
-          @children.delete_if { |child| targets.include?(child) }
-          @children.each { |child| child.prune!(targets) }
+          @as_array << [string(file), string(method), int(line)]
+          @as_array << int(@runnable_count)
+          @as_array << 0
+          @as_array << child_arrays
         end
 
         def dump_string(indent=0)