newrelic_rpm 3.12.0.288 → 3.12.1.298

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

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

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

@@ -62,6 +62,10 @@ module NewRelic
         end
 
         class Base
+          def initialize
+            @broken = false
+          end
+
           def can_run?
             return false if @broken
             m = get_memory rescue nil
@@ -86,11 +90,11 @@ module NewRelic
         end
 
         class JavaHeapSampler < Base
-
           def get_memory
             raise "Can't sample Java heap unless running in JRuby" unless defined? JRuby
             java.lang.Runtime.getRuntime.totalMemory / (1024 * 1024).to_f rescue nil
           end
+
           def to_s
             "JRuby Java heap sampler"
           end
@@ -101,6 +105,7 @@ module NewRelic
             super()
             @command = command
           end
+
           # Returns the amount of resident memory this process is using in MB
           #
           def get_memory
@@ -121,9 +126,7 @@ module NewRelic
         # A class that samples memory by reading the file /proc/$$/status, which is specific to linux
         #
         class ProcStatus < Base
-
           # Returns the amount of resident memory this process is using in MB
-          #
           def get_memory
             proc_status = File.open(proc_status_file, "r") {|f| f.read_nonblock(4096).strip }
             if proc_status =~ /RSS:\s*(\d+) kB/i

data/lib/new_relic/agent/sql_sampler.rb

@@ -6,9 +6,6 @@ require 'zlib'
 require 'base64'
 require 'digest/md5'
 
-require 'new_relic/agent'
-require 'new_relic/control'
-
 module NewRelic
   module Agent
     # This class contains the logic of recording slow SQL traces, which may
@@ -27,13 +24,6 @@ module NewRelic
     #
     # @api public
     class SqlSampler
-
-      # Module defining methods stubbed out when the agent is disabled
-      module Shim
-        def on_start_transaction(*args); end
-        def on_finishing_transaction(*args); end
-      end
-
       attr_reader :disabled
 
       # this is for unit tests only
@@ -150,7 +140,7 @@ module NewRelic
       # @api public
       # @deprecated Use {Datastores.notice_sql} instead.
       #
-      def notice_sql(sql, metric_name, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
+      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil) #THREAD_LOCAL_ACCESS sometimes
         state ||= TransactionState.tl_get
         data = state.sql_sampler_transaction_data
         return unless data
@@ -160,7 +150,7 @@ module NewRelic
             backtrace = caller.join("\n")
             data.sql_data << SlowSql.new(Database.capture_query(sql),
                                          metric_name, config,
-                                         duration, backtrace, &explainer)
+                                         duration, backtrace, explainer)
           end
         end
       end
@@ -223,8 +213,7 @@ module NewRelic
       attr_reader :duration
       attr_reader :backtrace
 
-      def initialize(sql, metric_name, config, duration, backtrace=nil,
-                     &explainer)
+      def initialize(sql, metric_name, config, duration, backtrace=nil, explainer=nil)
         @sql = sql
         @metric_name = metric_name
         @config = config
@@ -244,7 +233,7 @@ module NewRelic
 
       def explain
         if @config && @explainer
-          NewRelic::Agent::Database.explain_sql(@sql, @config, &@explainer)
+          NewRelic::Agent::Database.explain_sql(@sql, @config, @explainer)
         end
       end
 

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

@@ -229,7 +229,7 @@ module NewRelic
 
         # For use by test code only.
         def to_h
-          with_stats_lock { Hash[@stats_hash] }
+          with_stats_lock { @stats_hash.to_h }
         end
       end
     end

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

@@ -8,12 +8,6 @@ module Agent
   # Sampler functionality is now controlled by the SamplerManager class.
   # @deprecated
   class StatsEngine
-    module Shim # :nodoc:
-      def add_sampler(*args); end
-      def add_harvest_sampler(*args); end
-      def start_sampler_thread(*args); end
-    end
-
     module Samplers
       def add_sampler(*args)
         NewRelic::Agent.logger.warn("Ignoring request to add periodic sampler - add_sampler is deprecated")

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

@@ -2,10 +2,17 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# A Hash-descended class for storing metric data in the NewRelic Agent.
+# A Hash-like class for storing metric data.
 #
-# Keys are NewRelic::MetricSpec objects.
-# Values are NewRelic::Agent::Stats objects.
+# Internally, metrics are split into unscoped and scoped collections.
+#
+# Unscoped metrics are stored in a Hash, keyed by Strings representing the name
+# of the metrics.
+#
+# Scoped metrics are stored in a Hash where the keys are NewRelic::MetricSpec
+# objects (effectively <name, scope> tuples).
+#
+# Values in both hashes are NewRelic::Agent::Stats objects.
 #
 # Missing keys will be automatically created as empty NewRelic::Agent::Stats
 # instances, so use has_key? explicitly to check for key existence.
@@ -22,30 +29,68 @@ require 'new_relic/agent/internal_agent_error'
 
 module NewRelic
   module Agent
-    class StatsHash < ::Hash
+    class StatsHash
 
       attr_accessor :started_at, :harvested_at
 
       def initialize(started_at=Time.now)
         @started_at = started_at.to_f
-        super() { |hash, key| hash[key] = NewRelic::Agent::Stats.new }
+        @scoped     = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+        @unscoped   = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
       end
 
       def marshal_dump
-        [@started_at, Hash[self]]
+        [@started_at, Hash[@scoped], Hash[@unscoped]]
       end
 
       def marshal_load(data)
         @started_at = data.shift
-        self.merge!(data.shift)
+        @scoped   = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+        @unscoped = Hash.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
+        @scoped.merge!(data.shift)
+        @unscoped.merge!(data.shift)
       end
 
       def ==(other)
-        Hash[self] == Hash[other]
+        self.to_h == other.to_h
       end
 
       def to_h
-        Hash[self]
+        hash = {}
+        @scoped.each   { |k, v| hash[k] = v }
+        @unscoped.each { |k, v| hash[NewRelic::MetricSpec.new(k)] = v }
+        hash
+      end
+
+      def [](key)
+        case key
+        when String
+          @unscoped[key]
+        when NewRelic::MetricSpec
+          if key.scope.empty?
+            @unscoped[key.name]
+          else
+            @scoped[key]
+          end
+        end
+      end
+
+      def each
+        @scoped.each do |k, v|
+          yield k, v
+        end
+        @unscoped.each do |k, v|
+          spec = NewRelic::MetricSpec.new(k)
+          yield spec, v
+        end
+      end
+
+      def empty?
+        @unscoped.empty? && @scoped.empty?
+      end
+
+      def size
+        @unscoped.size + @scoped.size
       end
 
       class StatsHashLookupError < NewRelic::Agent::InternalAgentError
@@ -56,54 +101,66 @@ module NewRelic
 
       def record(metric_specs, value=nil, aux=nil, &blk)
         Array(metric_specs).each do |metric_spec|
-          stats = nil
+          if metric_spec.scope.empty?
+            key = metric_spec.name
+            hash = @unscoped
+          else
+            key = metric_spec
+            hash = @scoped
+          end
+
           begin
-            stats = self[metric_spec]
+            stats = hash[key]
           rescue NoMethodError => e
-            # This only happen in the case of a corrupted default_proc
-            # Side-step it manually, notice the issue, and carry on....
-            NewRelic::Agent.instance.error_collector. \
-              notice_agent_error(StatsHashLookupError.new(e, self, metric_spec))
-
-            stats = NewRelic::Agent::Stats.new
-            self[metric_spec] = stats
-
-            # Try to restore the default_proc so we won't continually trip the error
-            if respond_to?(:default_proc=)
-              self.default_proc = Proc.new { |hash, key| hash[key] = NewRelic::Agent::Stats.new }
-            end
+            stats = handle_stats_lookup_error(key, hash, e)
           end
 
           stats.record(value, aux, &blk)
         end
       end
 
-      def merge!(other)
-        if other.is_a?(StatsHash) && other.started_at < @started_at
-          @started_at = other.started_at
+      def handle_stats_lookup_error(key, hash, error)
+        # This only happen in the case of a corrupted default_proc
+        # Side-step it manually, notice the issue, and carry on....
+        NewRelic::Agent.instance.error_collector. \
+          notice_agent_error(StatsHashLookupError.new(error, hash, key))
+        stats = NewRelic::Agent::Stats.new
+        hash[key] = stats
+        # Try to restore the default_proc so we won't continually trip the error
+        if hash.respond_to?(:default_proc=)
+          hash.default_proc = Proc.new { |h, k| h[k] = NewRelic::Agent::Stats.new }
         end
-        other.each do |key, val|
-          merge_or_insert(key, val)
+        stats
+      end
+
+      def merge!(other)
+        @started_at = other.started_at if other.started_at < @started_at
+
+        other.each do |spec, val|
+          if spec.scope.empty?
+            merge_or_insert(@unscoped, spec.name, val)
+          else
+            merge_or_insert(@scoped, spec, val)
+          end
         end
         self
       end
 
       def merge_transaction_metrics!(txn_metrics, scope)
         txn_metrics.each_unscoped do |name, stats|
-          spec = NewRelic::MetricSpec.new(name)
-          merge_or_insert(spec, stats)
+          merge_or_insert(@unscoped, name, stats)
         end
         txn_metrics.each_scoped do |name, stats|
           spec = NewRelic::MetricSpec.new(name, scope)
-          merge_or_insert(spec, stats)
+          merge_or_insert(@scoped, spec, stats)
         end
       end
 
-      def merge_or_insert(metric_spec, stats)
-        if self.has_key?(metric_spec)
-          self[metric_spec].merge!(stats)
+      def merge_or_insert(target, name, stats)
+        if target.has_key?(name)
+          target[name].merge!(stats)
         else
-          self[metric_spec] = stats
+          target[name] = stats
         end
       end
     end

data/lib/new_relic/agent/system_info.rb

@@ -16,15 +16,27 @@ module NewRelic
         RbConfig::CONFIG['target_os']
       end
 
+      def self.darwin?
+        !!(ruby_os_identifier =~ /darwin/i)
+      end
+
+      def self.linux?
+        !!(ruby_os_identifier =~ /linux/i)
+      end
+
+      def self.bsd?
+        !!(ruby_os_identifier =~ /bsd/i)
+      end
+
+      @processor_info = nil
+
       def self.clear_processor_info
         @processor_info = nil
       end
 
       def self.get_processor_info
         if @processor_info.nil?
-          case ruby_os_identifier
-
-          when /darwin/
+          if darwin?
             @processor_info = {
               :num_physical_packages  => sysctl_value('hw.packages').to_i,
               :num_physical_cores     => sysctl_value('hw.physicalcpu_max').to_i,
@@ -41,11 +53,11 @@ module NewRelic
               @processor_info[:num_logical_processors] = sysctl_value('hw.ncpu').to_i
             end
 
-          when /linux/
+          elsif linux?
             cpuinfo = proc_try_read('/proc/cpuinfo')
             @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : {}
 
-          when /freebsd/
+          elsif bsd?
             @processor_info = {
               :num_physical_packages  => nil,
               :num_physical_cores     => nil,
@@ -146,7 +158,7 @@ module NewRelic
         cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
         return unless cpu_cgroup
 
-        case cpu_cgroup
+        container_id = case cpu_cgroup
         # docker native driver w/out systemd (fs)
         when %r{^/docker/([0-9a-f]+)$}                      then $1
         # docker native driver with systemd
@@ -156,9 +168,21 @@ module NewRelic
         # not in any cgroup
         when '/'                                            then nil
         # in a cgroup, but we don't recognize its format
+        when %r{docker}                                     then
+          ::NewRelic::Agent.logger.debug("Cgroup indicates docker but container_id unrecognized: '#{cpu_cgroup}'")
+          ::NewRelic::Agent.increment_metric "Supportability/utilization/docker/error"
+          return
         else
           ::NewRelic::Agent.logger.debug("Ignoring unrecognized cgroup ID format: '#{cpu_cgroup}'")
+          return
+        end
+
+        if container_id && container_id.size != 64
+          ::NewRelic::Agent.logger.debug("Found docker container_id with invalid length: #{container_id}")
+          ::NewRelic::Agent.increment_metric "Supportability/utilization/docker/error"
           nil
+        else
+          container_id
         end
       end
 
@@ -199,6 +223,29 @@ module NewRelic
         end
         content
       end
+
+      def self.ram_in_mib
+        if darwin?
+          sysctl_value('hw.memsize').to_i / (1024 ** 2)
+        elsif linux?
+          meminfo = proc_try_read('/proc/meminfo')
+          parse_linux_meminfo_in_mib(meminfo)
+        elsif bsd?
+          sysctl_value('hw.realmem').to_i / (1024 ** 2)
+        else
+          ::NewRelic::Agent.logger.debug("Unable to determine ram_in_mib for host os: #{ruby_os_identifier}")
+          nil
+        end
+      end
+
+      def self.parse_linux_meminfo_in_mib(meminfo)
+        if mem_total = meminfo[/MemTotal:\s*(\d*)\skB/,1]
+          mem_total.to_i / 1024
+        else
+          ::NewRelic::Agent.logger.debug("Failed to parse MemTotal from /proc/meminfo: #{meminfo}")
+          nil
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/transaction.rb

@@ -191,7 +191,7 @@ module NewRelic
         txn = state.current_transaction
         if txn
           txn.notice_error(e, options)
-        else
+        elsif NewRelic::Agent.instance
           NewRelic::Agent.instance.error_collector.notice_error(e, options)
         end
       end
@@ -308,10 +308,6 @@ module NewRelic
         @instrumentation_state ||= {}
       end
 
-      def noticed_error_ids
-        @noticed_error_ids ||= []
-      end
-
       def overridden_name=(name)
         @overridden_name = Helper.correctly_encoded(name)
       end
@@ -522,7 +518,7 @@ module NewRelic
         end
 
         if http_response_code
-          add_agent_attribute(:httpResponseCode, http_response_code,
+          add_agent_attribute(:httpResponseCode, http_response_code.to_s,
                               NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER|
                               NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS|
                               NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
@@ -579,15 +575,10 @@ module NewRelic
         append_apdex_perf_zone(duration, payload)
         append_synthetics_to(state, payload)
         append_referring_transaction_guid_to(state, payload)
-        append_http_response_code(payload)
 
         agent.events.notify(:transaction_finished, payload)
       end
 
-      def append_http_response_code(payload)
-        payload[:http_response_code] = http_response_code if http_response_code
-      end
-
       def include_guid?(state, duration)
         state.is_cross_app? || is_synthetics_request?
       end
@@ -800,7 +791,7 @@ module NewRelic
         Agent.config[key] && Agent.config[key][best_name]
       end
 
-      def with_database_metric_name(model, method)
+      def with_database_metric_name(model, method, product=nil)
         previous = self.instrumentation_state[:datastore_override]
         model_name = case model
                      when Class
@@ -810,7 +801,7 @@ module NewRelic
                      else
                        model.to_s
                      end
-        self.instrumentation_state[:datastore_override] = [method, model_name]
+        self.instrumentation_state[:datastore_override] = [method, model_name, product]
         yield
       ensure
         self.instrumentation_state[:datastore_override] = previous