newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/new_relic_service.rb

@@ -291,7 +291,7 @@ module NewRelic
         data, size, serialize_finish_ts = nil
         begin
           data = @marshaller.dump(args)
-        rescue => e
+        rescue StandardError, SystemStackError => e
           handle_serialization_error(method, e)
         end
         serialize_finish_ts = Time.now

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -149,7 +149,7 @@ module NewRelic
         def start
           return if @started == true
           @started = true
-          @thread = NewRelic::Agent::Threading::AgentThread.new('Pipe Channel Manager') do
+          @thread = NewRelic::Agent::Threading::AgentThread.create('Pipe Channel Manager') do
             now = nil
             loop do
               clean_up_pipes
@@ -229,8 +229,8 @@ module NewRelic
             Marshal.load(data)
           end
         rescue StandardError => e
-          msg = "#{e.class.name} '#{e.message}' trying to load #{Base64.encode64(data)}"
-          ::NewRelic::Agent.logger.debug(msg)
+          ::NewRelic::Agent.logger.error "Failure unmarshalling message from Resque child process", e
+          ::NewRelic::Agent.logger.debug Base64.encode64(data)
           nil
         end
 

data/lib/new_relic/agent/request_sampler.rb

@@ -77,7 +77,7 @@ class NewRelic::Agent::RequestSampler
     end
   end
 
-  def record_sampling_rate(request_count, sample_count)
+  def record_sampling_rate(request_count, sample_count) #THREAD_LOCAL_ACCESS
     request_count_lifetime = @samples.seen_lifetime
     sample_count_lifetime = @samples.captured_lifetime
     NewRelic::Agent.logger.debug("Sampled %d / %d (%.1f %%) requests this cycle, %d / %d (%.1f %%) since startup" % [
@@ -90,8 +90,8 @@ class NewRelic::Agent::RequestSampler
     ])
 
     engine = NewRelic::Agent.instance.stats_engine
-    engine.record_supportability_metric_count("RequestSampler/requests", request_count)
-    engine.record_supportability_metric_count("RequestSampler/samples", sample_count)
+    engine.tl_record_supportability_metric_count("RequestSampler/requests", request_count)
+    engine.tl_record_supportability_metric_count("RequestSampler/samples", sample_count)
   end
 
   def register_config_callbacks
@@ -125,11 +125,10 @@ class NewRelic::Agent::RequestSampler
   def self.map_metric(metric_name, to_add={})
     to_add.values.each(&:freeze)
 
-    spec = ::NewRelic::MetricSpec.new(metric_name)
-    mappings = OVERVIEW_SPECS.fetch(spec, {})
+    mappings = OVERVIEW_SPECS.fetch(metric_name, {})
     mappings.merge!(to_add)
 
-    OVERVIEW_SPECS[spec] = mappings
+    OVERVIEW_SPECS[metric_name] = mappings
   end
 
   OVERVIEW_SPECS = {}
@@ -154,12 +153,12 @@ class NewRelic::Agent::RequestSampler
   map_metric('External/allOther',     :total_call_time => "externalDuration")
   map_metric('External/allOther',     :call_count      => "externalCallCount")
 
-  def extract_metrics(stats_hash)
+  def extract_metrics(txn_metrics)
     result = {}
-    if stats_hash
-      OVERVIEW_SPECS.each do |(metric_spec, extracted_values)|
-        if stats_hash.has_key?(metric_spec)
-          stat = stats_hash[metric_spec]
+    if txn_metrics
+      OVERVIEW_SPECS.each do |(name, extracted_values)|
+        if txn_metrics.has_key?(name)
+          stat = txn_metrics[name]
           extracted_values.each do |value_name, key_name|
             result[key_name] = stat.send(value_name)
           end

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

@@ -49,7 +49,7 @@ module NewRelic
           end
         end
 
-        def record_gc_runs_metric(snapshot, txn_count)
+        def record_gc_runs_metric(snapshot, txn_count) #THREAD_LOCAL_ACCESS
           if snapshot.gc_total_time || snapshot.gc_runs
             if snapshot.gc_total_time
               gc_time = snapshot.gc_total_time - @last_snapshot.gc_total_time.to_f
@@ -58,7 +58,7 @@ module NewRelic
               gc_runs = snapshot.gc_runs - @last_snapshot.gc_runs
             end
             wall_clock_time = snapshot.taken_at - @last_snapshot.taken_at
-            NewRelic::Agent.agent.stats_engine.record_metrics(GC_RUNS_METRIC) do |stats|
+            NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(GC_RUNS_METRIC) do |stats|
               stats.call_count           += txn_count
               stats.total_call_time      += gc_runs if gc_runs
               stats.total_exclusive_time += gc_time if gc_time
@@ -68,19 +68,19 @@ module NewRelic
           end
         end
 
-        def record_delta(snapshot, key, metric, txn_count)
+        def record_delta(snapshot, key, metric, txn_count) #THREAD_LOCAL_ACCESS
           value = snapshot.send(key)
           if value
             delta = value - @last_snapshot.send(key)
-            NewRelic::Agent.agent.stats_engine.record_metrics(metric) do |stats|
+            NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metric) do |stats|
               stats.call_count      += txn_count
               stats.total_call_time += delta
             end
           end
         end
 
-        def record_gauge_metric(metric_name, value)
-          NewRelic::Agent.agent.stats_engine.record_metrics(metric_name) do |stats|
+        def record_gauge_metric(metric_name, value) #THREAD_LOCAL_ACCESS
+          NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
             stats.call_count      = value
             stats.sum_of_squares  = 1
           end

data/lib/new_relic/agent/shim_agent.rb

@@ -11,6 +11,7 @@ module NewRelic
       def self.instance
         @instance ||= self.new
       end
+
       def initialize
         super
         @stats_engine.extend NewRelic::Agent::StatsEngine::Shim
@@ -18,6 +19,7 @@ module NewRelic
         @sql_sampler.extend NewRelic::Agent::SqlSampler::Shim
         @error_collector.extend NewRelic::Agent::ErrorCollector::Shim
       end
+
       def after_fork *args; end
       def start *args; end
       def shutdown *args; end
@@ -25,7 +27,6 @@ module NewRelic
       def push_trace_execution_flag *args; end
       def pop_trace_execution_flag *args; end
       def browser_timing_header; "" end
-      def browser_timing_config; "" end
       def browser_timing_footer; "" end
     end
   end

data/lib/new_relic/agent/sql_sampler.rb

@@ -11,6 +11,21 @@ require 'new_relic/control'
 
 module NewRelic
   module Agent
+    # This class contains the logic of recording slow SQL traces, which may
+    # represent multiple aggregated SQL queries.
+    #
+    # A slow SQL trace consists of a collection of SQL instrumented SQL queries
+    # that all normalize to the same text. For example, the following two
+    # queries would be aggregated together into a single slow SQL trace:
+    #
+    #   SELECT * FROM table WHERE id=42
+    #   SELECT * FROM table WHERE id=1234
+    #
+    # Each slow SQL trace keeps track of the number of times the same normalized
+    # query was seen, the min, max, and total time spent executing those
+    # queries, and an example backtrace from one of the aggregated queries.
+    #
+    # @api public
     class SqlSampler
 
       # Module defining methods stubbed out when the agent is disabled
@@ -26,7 +41,6 @@ module NewRelic
 
       def initialize
         @sql_traces = {}
-        clear_transaction_data
 
         # This lock is used to synchronize access to @sql_traces
         # and related variables. It can become necessary on JRuby or
@@ -41,31 +55,26 @@ module NewRelic
           Agent.config[:'transaction_tracer.enabled']
       end
 
-      def on_start_transaction(start_time, uri=nil, params={})
-        TransactionState.get.sql_sampler_transaction_data = TransactionSqlData.new
+      def on_start_transaction(state, start_time, uri=nil)
+        state.sql_sampler_transaction_data = TransactionSqlData.new
 
-        if NewRelic::Agent.instance.transaction_sampler.builder
-          guid = NewRelic::Agent.instance.transaction_sampler.builder.sample.guid
+        if state.transaction_sample_builder
+          guid = state.transaction_sample_builder.sample.guid
         end
 
-        if Agent.config[:'slow_sql.enabled'] && transaction_data
-          transaction_data.set_transaction_info(uri, params, guid)
+        if Agent.config[:'slow_sql.enabled'] && state.sql_sampler_transaction_data
+          state.sql_sampler_transaction_data.set_transaction_info(uri, guid)
         end
       end
 
-      def transaction_data
-        TransactionState.get.sql_sampler_transaction_data
-      end
-
-      def clear_transaction_data
-        TransactionState.get.sql_sampler_transaction_data = nil
+      def tl_transaction_data # only used for testing
+        TransactionState.tl_get.sql_sampler_transaction_data
       end
 
       # This is called when we are done with the transaction.
-      def on_finishing_transaction(name, time=Time.now)
-        data = transaction_data
+      def on_finishing_transaction(state, name, time=Time.now)
+        data = state.sql_sampler_transaction_data
         data.set_transaction_name(name)
-        clear_transaction_data
 
         if data.sql_data.size > 0
           @samples_lock.synchronize do
@@ -91,14 +100,33 @@ module NewRelic
         end
       end
 
-      def notice_sql(sql, metric_name, config, duration, &explainer)
-        return unless transaction_data
-        if NewRelic::Agent.is_sql_recorded?
+      # Records an SQL query, potentially creating a new slow SQL trace, or
+      # aggregating the query into an existing slow SQL trace.
+      #
+      # This method should be used only by gem authors wishing to extend
+      # the Ruby agent to instrument new database interfaces - it should
+      # generally not be called directly from application code.
+      #
+      # @param sql [String] the SQL query being recorded
+      # @param metric_name [String] is the metric name under which this query will be recorded
+      # @param config [Object] is the driver configuration for the connection
+      # @param duration [Float] number of seconds the query took to execute
+      # @param explainer [Proc] for internal use only - 3rd-party clients must
+      #                         not pass this parameter.
+      #
+      # @api public
+      #
+      def notice_sql(sql, metric_name, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
+        state ||= TransactionState.tl_get
+        data = state.sql_sampler_transaction_data
+        return unless data
+
+        if state.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
-            transaction_data.sql_data << SlowSql.new(Database.capture_query(sql),
-                                                     metric_name, config,
-                                                     duration, backtrace, &explainer)
+            data.sql_data << SlowSql.new(Database.capture_query(sql),
+                                         metric_name, config,
+                                         duration, backtrace, &explainer)
           end
         end
       end
@@ -138,7 +166,6 @@ module NewRelic
     class TransactionSqlData
       attr_reader :path
       attr_reader :uri
-      attr_reader :params
       attr_reader :sql_data
       attr_reader :guid
 
@@ -146,9 +173,8 @@ module NewRelic
         @sql_data = []
       end
 
-      def set_transaction_info(uri, params, guid)
+      def set_transaction_info(uri, guid)
         @uri = uri
-        @params = params
         @guid = guid
       end
 
@@ -205,7 +231,7 @@ module NewRelic
 
       def initialize(normalized_query, slow_sql, path, uri)
         super()
-        @params = {} #FIXME
+        @params = {}
         @sql_id = consistent_hash(normalized_query)
         set_primary slow_sql, path, uri
         record_data_point(float(slow_sql.duration))
@@ -217,7 +243,6 @@ module NewRelic
         @database_metric_name = slow_sql.metric_name
         @path = path
         @url = uri
-        # FIXME
         @params[:backtrace] = slow_sql.backtrace if slow_sql.backtrace
       end
 

data/lib/new_relic/agent/stats.rb

@@ -33,20 +33,18 @@ module NewRelic
         stats.merge!(other_stats)
       end
 
-      def merge!(other_stats)
-        Array(other_stats).each do |other|
-          @min_call_time = other.min_call_time if min_time_less?(other)
-          @max_call_time = other.max_call_time if other.max_call_time > max_call_time
-          @total_call_time      += other.total_call_time
-          @total_exclusive_time += other.total_exclusive_time
-          @sum_of_squares       += other.sum_of_squares
-          @call_count += other.call_count
-        end
+      def merge!(other)
+        @min_call_time = other.min_call_time if min_time_less?(other)
+        @max_call_time = other.max_call_time if other.max_call_time > max_call_time
+        @total_call_time      += other.total_call_time
+        @total_exclusive_time += other.total_exclusive_time
+        @sum_of_squares       += other.sum_of_squares
+        @call_count += other.call_count
         self
       end
 
       def to_s
-        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s]"
+        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s / #{'%.4f' % total_exclusive_time.to_f}s ex]"
       end
 
       def to_json(*_)
@@ -60,6 +58,22 @@ module NewRelic
         }.to_json(*_)
       end
 
+      def record(value=nil, aux=nil, &blk)
+        if blk
+          yield self
+        else
+          case value
+          when Numeric
+            aux ||= value
+            self.record_data_point(value, aux)
+          when :apdex_s, :apdex_t, :apdex_f
+            self.record_apdex(value, aux)
+          when NewRelic::Agent::Stats
+            self.merge!(value)
+          end
+        end
+      end
+
       # record a single data point into the statistical gatherer.  The gatherer
       # will aggregate all data points collected over a specified period and upload
       # its data to the NewRelic server

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

@@ -45,8 +45,8 @@ module NewRelic
           end
         end
 
-        def self.record_gc_metric(call_count, elapsed)
-          NewRelic::Agent.agent.stats_engine.record_metrics(gc_metric_specs) do |stats|
+        def self.record_gc_metric(call_count, elapsed) #THREAD_LOCAL_ACCESS
+          NewRelic::Agent.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(gc_metric_name, GC_ROLLUP) do |stats|
             stats.call_count           += call_count
             stats.total_call_time      += elapsed
             stats.total_exclusive_time += elapsed
@@ -57,23 +57,11 @@ module NewRelic
         GC_OTHER  = 'GC/Transaction/allOther'.freeze
         GC_WEB    = 'GC/Transaction/allWeb'.freeze
 
-        SCOPE_PLACEHOLDER = NewRelic::Agent::StatsEngine::MetricStats::SCOPE_PLACEHOLDER
-
-        GC_ROLLUP_SPEC       = NewRelic::MetricSpec.new(GC_ROLLUP)
-        GC_OTHER_SPEC        = NewRelic::MetricSpec.new(GC_OTHER)
-        GC_OTHER_SCOPED_SPEC = NewRelic::MetricSpec.new(GC_OTHER, SCOPE_PLACEHOLDER)
-        GC_WEB_SPEC          = NewRelic::MetricSpec.new(GC_WEB)
-        GC_WEB_SCOPED_SPEC   = NewRelic::MetricSpec.new(GC_WEB, SCOPE_PLACEHOLDER)
-
-        def self.gc_metric_specs
-          # The .dup call on the scoped MetricSpec here is necessary because
-          # metric specs with non-empty scopes will have their scopes mutated
-          # when the metrics are merged into the global stats hash, and we don't
-          # want to mutate the original MetricSpec.
+        def self.gc_metric_name
           if NewRelic::Agent::Transaction.recording_web_transaction?
-            [GC_ROLLUP_SPEC, GC_WEB_SPEC, GC_WEB_SCOPED_SPEC.dup]
+            GC_WEB
           else
-            [GC_ROLLUP_SPEC, GC_OTHER_SPEC, GC_OTHER_SCOPED_SPEC.dup]
+            GC_OTHER
           end
         end
 

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

@@ -9,58 +9,127 @@ module NewRelic
     class StatsEngine
       # Handles methods related to actual Metric collection
       module MetricStats
-        SCOPE_PLACEHOLDER = :__SCOPE__
+        SCOPE_PLACEHOLDER = '__SCOPE__'.freeze
 
-        # Lookup and write to the named metric in a single call.
+        # Update the unscoped metrics given in metric_names.
+        # metric_names may be either a single name, or an array of names.
         #
-        # This method is thead-safe, and is preferred to the lookup / modify
-        # method pairs (e.g. get_stats + record_data_point)
+        # This is an internal method, subject to change at any time. Client apps
+        # and gems should use the public API (NewRelic::Agent.record_metric)
+        # instead.
+        #
+        # There are four ways to use this method:
+        #
+        # 1. With a numeric value, it will update the Stats objects associated
+        #    with the given metrics by calling record_data_point(value, aux).
+        #    aux will be treated in this case as the exclusive time associated
+        #    with the call being recorded.
+        #
+        # 2. With a value of :apdex_s, :apdex_t, or :apdex_f, it will treat the
+        #    associated stats as an Apdex metric, updating it to reflect the
+        #    occurrence of a transaction falling into the given category.
+        #    The aux value in this case should be the apdex threshold used in
+        #    bucketing the request.
+        #
+        # 3. If a block is given, value and aux will be ignored, and instead the
+        #    Stats object associated with each named unscoped metric will be
+        #    yielded to the block for customized update logic.
+        #
+        # 4. If value is a Stats instance, it will be merged into the Stats
+        #    associated with each named unscoped metric.
+        #
+        # If this method is called during a transaction, the metrics will be
+        # attached to the Transaction, and not merged into the global set until
+        # the end of the transaction.
+        #
+        # Otherwise, the metrics will be recorded directly into the global set
+        # of metrics, under a lock.
         #
         # @api private
-        def record_metrics(metric_names_or_specs, value=nil, options={}, &blk)
-          scoped = options[:scoped]
-          scope = in_transaction? ? SCOPE_PLACEHOLDER : nil
-          effective_scope = scoped && scope
-
-          specs = coerce_to_metric_spec_array(metric_names_or_specs, effective_scope)
+        #
+        def tl_record_unscoped_metrics(metric_names, value=nil, aux=nil, &blk)
+          state = NewRelic::Agent::TransactionState.tl_get
+          record_unscoped_metrics(state, metric_names, value, aux, &blk)
+        end
 
-          if in_transaction?
-            transaction_stats_hash.record(specs, value, &blk)
+        def record_unscoped_metrics(state, metric_names, value=nil, aux=nil, &blk)
+          txn = state.current_transaction
+          if txn
+            txn.metrics.record_unscoped(metric_names, value, aux, &blk)
           else
+            specs = coerce_to_metric_spec_array(metric_names, nil)
             with_stats_lock do
-              @stats_hash.record(specs, value, &blk)
+              @stats_hash.record(specs, value, aux, &blk)
             end
           end
         end
 
-        # Fast-path version of the #record_metrics version above, used in
-        # performance-sensitive code paths
+        # Like tl_record_unscoped_metrics, but records a scoped metric as well.
         #
-        # metric_specs must be an Array of MetricSpec objects
-        # value and aux are passed directly to the corresponding parameters of
-        # StatsHash#record
+        # This is an internal method, subject to change at any time. Client apps
+        # and gems should use the public API (NewRelic::Agent.record_metric)
+        # instead.
+        #
+        # The given scoped_metric will be recoded as both a scoped *and* an
+        # unscoped metric. The summary_metrics will be recorded as unscoped
+        # metrics only.
+        #
+        # If called during a transaction, all metrics will be attached to the
+        # Transaction, and not merged into the global set of metrics until the
+        # end of the transaction.
+        #
+        # If called outside of a transaction, only the *unscoped* metrics will
+        # be recorded, directly into the global set of metrics (under a lock).
         #
         # @api private
-        def record_metrics_internal(metric_specs, value, aux)
-          tsh = transaction_stats_hash
-          if tsh
-            tsh.record(metric_specs, value, aux)
+        #
+        def tl_record_scoped_and_unscoped_metrics(scoped_metric, summary_metrics=nil, value=nil, aux=nil, &blk)
+          state = NewRelic::Agent::TransactionState.tl_get
+          record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics, value, aux, &blk)
+        end
+
+        def record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics=nil, value=nil, aux=nil, &blk)
+          txn = state.current_transaction
+          if txn
+            txn.metrics.record_scoped(scoped_metric, value, aux, &blk)
+            txn.metrics.record_unscoped(scoped_metric, value, aux, &blk)
+            if summary_metrics
+              txn.metrics.record_unscoped(summary_metrics, value, aux, &blk)
+            end
           else
+            specs = coerce_to_metric_spec_array(scoped_metric, nil)
+            if summary_metrics
+              specs.concat(coerce_to_metric_spec_array(summary_metrics, nil))
+            end
             with_stats_lock do
-              @stats_hash.record(metric_specs, value, aux)
+              @stats_hash.record(specs, value, aux, &blk)
             end
           end
         end
 
-        # a simple accessor for looking up a stat with no scope -
-        # returns a new stats object if no stats object for that
-        # metric exists yet
+        # This method is deprecated and not thread safe, and should not be used
+        # by any new client code. Use NewRelic::Agent.record_metric instead.
+        #
+        # Lookup the Stats object for a given unscoped metric, returning a new
+        # Stats object if one did not exist previously.
+        #
+        # @api public
+        # @deprecated
+        #
         def get_stats_no_scope(metric_name)
           get_stats(metric_name, false)
         end
 
-        # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
+        # This method is deprecated and not thread safe, and should not be used
+        # by any new client code. Use NewRelic::Agent.record_metric instead.
+        #
+        # If scoped_metric_only is true, only a scoped metric is created (used
+        # by rendering metrics which by definition are per controller only)
         # Leaving second, unused parameter for compatibility
+        #
+        # @api public
+        # @deprecated
+        #
         def get_stats(metric_name, _ = true, scoped_metric_only = false, scope = nil)
           stats = nil
           with_stats_lock do
@@ -81,8 +150,7 @@ module NewRelic
           stats
         end
 
-        # Returns a stat if one exists, otherwise returns nil. If you
-        # want auto-initialization, use one of get_stats or get_stats_no_scope
+        # Returns a stat if one exists, otherwise returns nil.
         def lookup_stats(metric_name, scope_name = '')
           spec = NewRelic::MetricSpec.new(metric_name, scope_name)
           with_stats_lock do
@@ -90,29 +158,11 @@ module NewRelic
           end
         end
 
-        # Helper method for timing supportability metrics
-        def record_supportability_metric_timed(metric)
-          start_time = Time.now
-          yield
-        ensure
-          duration = (Time.now - start_time).to_f
-          record_supportability_metric(metric, duration)
-        end
-
         # Helper for recording a straight value into the count
-        def record_supportability_metric_count(metric, value)
-          record_supportability_metric(metric) do |stat|
-            stat.call_count = value
-          end
-        end
-
-        # Helper method for recording supportability metrics consistently
-        def record_supportability_metric(metric, value=nil)
+        def tl_record_supportability_metric_count(metric, value)
           real_name = "Supportability/#{metric}"
-          if block_given?
-            record_metrics(real_name) { |stat| yield stat }
-          else
-            record_metrics(real_name, value)
+          tl_record_unscoped_metrics(real_name) do |stat|
+            stat.call_count = value
           end
         end
 
@@ -136,6 +186,12 @@ module NewRelic
           end
         end
 
+        def merge_transaction_metrics!(txn_metrics, scope)
+          with_stats_lock do
+            @stats_hash.merge_transaction_metrics!(txn_metrics, scope)
+          end
+        end
+
         def harvest!
           now = Time.now
           snapshot = reset!
@@ -187,14 +243,6 @@ module NewRelic
         def metric_specs
           with_stats_lock { @stats_hash.keys }
         end
-
-        def in_transaction?
-          !!transaction_stats_hash
-        end
-
-        def transaction_stats_hash
-          Transaction.current && Transaction.current.stats_hash
-        end
       end
     end
   end