newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/lib/new_relic/agent/system_info.rb

@@ -0,0 +1,54 @@
+# 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.
+
+# This module is intended to provide access to information about the host OS and
+# [virtual] machine. It intentionally does no caching and maintains no state -
+# caching should be handled by clients if needed. Methods should return nil if
+# the requested information is unavailable.
+
+require 'rbconfig'
+
+module NewRelic
+  module Agent
+    module SystemInfo
+      def self.ruby_os_identifier
+        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_file = '/proc/cpuinfo'
+          File.open(proc_file) do |f|
+            loop do
+              begin
+                cpuinfo << f.read_nonblock(4096).strip
+              rescue EOFError
+                break
+              rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+                cpuinfo = ''
+                break # don't select file handle, just give up
+              end
+            end
+          end
+          processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
+          processors == 0 ? nil : processors
+        end
+      rescue
+        nil
+      end
+
+      def self.processor_arch
+        RbConfig::CONFIG['target_cpu']
+      end
+
+      def self.os_version
+        `uname -v` rescue nil
+      end
+    end
+  end
+end

data/lib/new_relic/agent/thread.rb

@@ -15,8 +15,8 @@ module NewRelic
       def self.bucket_thread(thread, profile_agent_code)
         if thread.key?(:newrelic_label)
           return profile_agent_code ? :agent : :ignore
-        elsif !thread[:newrelic_metric_frame].nil?
-          thread[:newrelic_metric_frame].request.nil? ? :background : :request
+        elsif !thread[:newrelic_transaction].nil?
+          thread[:newrelic_transaction].request.nil? ? :background : :request
         else
           :other
         end

data/lib/new_relic/agent/transaction/pop.rb

@@ -0,0 +1,52 @@
+# 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.
+
+require 'new_relic/agent/instrumentation'
+module NewRelic
+  module Agent
+    class Transaction
+      module Pop
+        def log_underflow
+          ::NewRelic::Agent.logger.error "Underflow in transaction: #{caller.join("\n   ")}"
+        end
+
+        def record_transaction_cpu
+          burn = cpu_burn
+          transaction_sampler.notice_transaction_cpu_time(burn) if burn
+        end
+
+        def normal_cpu_burn
+          return unless @process_cpu_start
+          process_cpu - @process_cpu_start
+        end
+
+        def jruby_cpu_burn
+          return unless @jruby_cpu_start
+          burn = (jruby_cpu_time - @jruby_cpu_start)
+          # record_jruby_cpu_burn(burn)
+          burn
+        end
+
+        # we need to do this here because the normal cpu sampler
+        # process doesn't work on JRuby. See the cpu_sampler.rb file
+        # to understand where cpu is recorded for non-jruby processes
+        def record_jruby_cpu_burn(burn)
+          NewRelic::Agent.record_metric(NewRelic::Metrics::USER_TIME, burn)
+        end
+
+        def cpu_burn
+          normal_cpu_burn || jruby_cpu_burn
+        end
+
+        def traced?
+          NewRelic::Agent.is_execution_traced?
+        end
+
+        def current_stack_metric
+          metric_name
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction.rb

@@ -0,0 +1,388 @@
+# 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.
+
+require 'new_relic/agent/transaction/pop'
+
+# A struct holding the information required to measure a controller
+# action.  This is put on the thread local.  Handles the issue of
+# re-entrancy, or nested action calls.
+#
+# This class is not part of the public API.  Avoid making calls on it directly.
+#
+module NewRelic
+  module Agent
+    class Transaction
+      # helper module refactored out of the `pop` method
+      include Pop
+
+      attr_accessor :start_time  # A Time instance for the start time, never nil
+      attr_accessor :apdex_start # A Time instance used for calculating the apdex score, which
+      # might end up being @start, or it might be further upstream if
+      # we can find a request header for the queue entry time
+      attr_accessor(:type, :exceptions, :filtered_params, :force_flag,
+                    :jruby_cpu_start, :process_cpu_start, :database_metric_name)
+      attr_reader :name
+
+      # Give the current transaction a request context.  Use this to
+      # get the URI and referer.  The request is interpreted loosely
+      # as a Rack::Request or an ActionController::AbstractRequest.
+      attr_accessor :request
+
+
+      # Return the currently active transaction, or nil.  Call with +true+
+      # to create a new transaction if one is not already on the thread.
+      def self.current
+        self.stack.last
+      end
+
+      def self.start(transaction_type, options={})
+        txn = Transaction.new(transaction_type, options)
+        txn.start(transaction_type)
+        self.stack.push(txn)
+        return txn
+      end
+
+      def self.stop(metric_name=nil)
+        txn = self.stack.pop
+        txn.stop(metric_name) if txn
+        return txn
+      end
+
+      def self.stack
+        Thread.current[:newrelic_transaction] ||= []
+      end
+
+      def self.in_transaction?
+        !self.stack.empty?
+      end
+
+      # This is the name of the model currently assigned to database
+      # measurements, overriding the default.
+      def self.database_metric_name
+        current && current.database_metric_name
+      end
+
+      def self.referer
+        current && current.referer
+      end
+
+      def self.agent
+        NewRelic::Agent.instance
+      end
+
+      def self.freeze_name
+        self.current && self.current.freeze_name
+      end
+
+      @@java_classes_loaded = false
+
+      if defined? JRuby
+        begin
+          require 'java'
+          java_import 'java.lang.management.ManagementFactory'
+          java_import 'com.sun.management.OperatingSystemMXBean'
+          @@java_classes_loaded = true
+        rescue => e
+        end
+      end
+
+      attr_reader :depth
+
+      def initialize(type=:controller, options={})
+        @type = type
+        @start_time = Time.now
+        @jruby_cpu_start = jruby_cpu_time
+        @process_cpu_start = process_cpu
+        @filtered_params = options[:filtered_params] || {}
+        @force_flag = options[:force]
+        @request = options[:request]
+        @exceptions = {}
+        TransactionInfo.get.transaction = self
+      end
+
+      def name=(name)
+        if !@name_frozen
+          @name = name
+        else
+          NewRelic::Agent.logger.warn("Attempted to rename transaction to #{name} after transaction name was already frozen.")
+        end
+      end
+
+      def freeze_name
+        return if name_frozen?
+        @name = NewRelic::Agent.instance.transaction_rules.rename(@name)
+        @name_frozen = true
+      end
+
+      def name_frozen?
+        @name_frozen
+      end
+
+      def has_parent?
+        self.class.stack.size > 1
+      end
+
+      # Indicate that we are entering a measured controller action or task.
+      # Make sure you unwind every push with a pop call.
+      def start(transaction_type)
+        transaction_sampler.notice_first_scope_push(start_time)
+        sql_sampler.notice_first_scope_push(start_time)
+
+        NewRelic::Agent::StatsEngine::GCProfiler.init
+        agent.stats_engine.start_transaction
+        agent.stats_engine.push_transaction_stats
+        transaction_sampler.notice_transaction(uri, filtered_params)
+        sql_sampler.notice_transaction(uri, filtered_params)
+      end
+
+      # Indicate that you don't want to keep the currently saved transaction
+      # information
+      def self.abort_transaction!
+        current.abort_transaction! if current
+      end
+
+      # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
+      def uri
+        @uri ||= self.class.uri_from_request(@request) unless @request.nil?
+      end
+
+      # For the current web transaction, return the full referer, minus the host string, or nil.
+      def referer
+        @referer ||= self.class.referer_from_request(@request)
+      end
+
+      # Call this to ensure that the current transaction is not saved
+      def abort_transaction!
+        transaction_sampler.ignore_transaction
+      end
+
+      # Unwind one stack level.  It knows if it's back at the outermost caller and
+      # does the appropriate wrapup of the context.
+      def stop(metric='(unknown)')
+        @name ||= metric unless name_frozen?
+        freeze_name
+        log_underflow if @type.nil?
+
+        # these record metrics so need to be done before
+        # the pop
+        if self.class.stack.empty?
+          # this one records metrics and wants to happen
+          # before the transaction sampler is finished
+          if traced?
+            record_transaction_cpu
+            gc_time = NewRelic::Agent::StatsEngine::GCProfiler.capture
+          end
+          @transaction_trace = transaction_sampler.notice_scope_empty(self, Time.now, gc_time)
+          sql_sampler.notice_scope_empty(@name)
+        end
+
+        record_exceptions
+        agent.stats_engine.pop_transaction_stats(@name)
+
+        # these tear everything down so need to be done
+        # after the pop
+        if self.class.stack.empty?
+          agent.stats_engine.end_transaction
+        end
+      end
+
+      def record_exceptions
+        @exceptions.each do |exception, options|
+          options[:metric] = @name
+          agent.error_collector.notice_error(exception, options)
+        end
+      end
+
+      # If we have an active transaction, notice the error and increment the error metric.
+      # Options:
+      # * <tt>:request</tt> => Request object to get the uri and referer
+      # * <tt>:uri</tt> => The request path, minus any request params or query string.
+      # * <tt>:referer</tt> => The URI of the referer
+      # * <tt>:metric</tt> => The metric name associated with the transaction
+      # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+      # * <tt>:custom_params</tt> => Custom parameters
+      # Anything left over is treated as custom params
+
+      def self.notice_error(e, options={})
+        request = options.delete(:request)
+        if request
+          options[:referer] = referer_from_request(request)
+          options[:uri] = uri_from_request(request)
+        end
+        if current
+          current.notice_error(e, options)
+        else
+          agent.error_collector.notice_error(e, options)
+        end
+      end
+
+      # Do not call this.  Invoke the class method instead.
+      def notice_error(e, options={}) # :nodoc:
+        params = custom_parameters
+        options[:referer] = referer if referer
+        options[:request_params] = filtered_params if filtered_params
+        options[:uri] = uri if uri
+        options.merge!(custom_parameters)
+        if !@exceptions.keys.include?(e)
+          @exceptions[e] = options
+        end
+      end
+
+      # Add context parameters to the transaction.  This information will be passed in to errors
+      # and transaction traces.  Keys and Values should be strings, numbers or date/times.
+      def self.add_custom_parameters(p)
+        current.add_custom_parameters(p) if current
+      end
+
+      def self.custom_parameters
+        (current && current.custom_parameters) ? current.custom_parameters : {}
+      end
+
+      def self.set_user_attributes(attributes)
+        current.set_user_attributes(attributes) if current
+      end
+
+      def self.user_attributes
+        (current) ? current.user_attributes : {}
+      end
+
+      def record_apdex(metric_name)
+        return unless recording_web_transaction? && NewRelic::Agent.is_execution_traced?
+        metric_parser = NewRelic::MetricParser::MetricParser \
+          .for_metric_named(metric_name)
+
+        t = Time.now
+        self.class.record_apdex(metric_parser, t - start_time, t - apdex_start, exceptions.any?)
+      end
+
+      # Yield to a block that is run with a database metric name context.  This means
+      # the Database instrumentation will use this for the metric name if it does not
+      # otherwise know about a model.  This is re-entrant.
+      #
+      # * <tt>model</tt> is the DB model class
+      # * <tt>method</tt> is the name of the finder method or other method to identify the operation with.
+      #
+      def with_database_metric_name(model, method)
+        previous = @database_metric_name
+        model_name = case model
+                     when Class
+                       model.name
+                     when String
+                       model
+                     else
+                       model.to_s
+                     end
+        @database_metric_name = "ActiveRecord/#{model_name}/#{method}"
+        yield
+      ensure
+        @database_metric_name=previous
+      end
+
+      def custom_parameters
+        @custom_parameters ||= {}
+      end
+
+      def user_attributes
+        @user_atrributes ||= {}
+      end
+
+      def queue_time
+        @apdex_start ? @start_time - @apdex_start : 0
+      end
+
+      def add_custom_parameters(p)
+        custom_parameters.merge!(p)
+      end
+
+      def set_user_attributes(attributes)
+        user_attributes.merge!(attributes)
+      end
+
+      def self.recording_web_transaction?
+        self.current && self.current.recording_web_transaction?
+      end
+
+      def recording_web_transaction?
+        [:controller, :uri, :rack, :sinatra].include?(@type)
+      end
+
+      # Make a safe attempt to get the referer from a request object, generally successful when
+      # it's a Rack request.
+      def self.referer_from_request(request)
+        if request && request.respond_to?(:referer)
+          request.referer.to_s.split('?').first
+        end
+      end
+
+      # Make a safe attempt to get the URI, without the host and query string.
+      def self.uri_from_request(request)
+        approximate_uri = case
+                          when request.respond_to?(:fullpath) then request.fullpath
+                          when request.respond_to?(:path) then request.path
+                          when request.respond_to?(:request_uri) then request.request_uri
+                          when request.respond_to?(:uri) then request.uri
+                          when request.respond_to?(:url) then request.url
+                          end
+        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri # '
+      end
+
+      def self.record_apdex(current_metric, action_duration, total_duration, is_error)
+        agent.stats_engine.record_metrics('Apdex') do |stat|
+          update_apdex(stat, total_duration, is_error)
+        end
+        agent.stats_engine.record_metrics(current_metric.apdex_metric_path) do |stat|
+          update_apdex(stat, action_duration, is_error)
+        end
+      end
+
+      # Record an apdex value for the given stat.  when `failed`
+      # the apdex should be recorded as a failure regardless of duration.
+      def self.update_apdex(stat, duration, failed)
+        apdex_t = TransactionInfo.get.apdex_t
+        duration = duration.to_f
+        case
+        when failed
+          stat.record_apdex_f
+        when duration <= apdex_t
+          stat.record_apdex_s
+        when duration <= 4 * apdex_t
+          stat.record_apdex_t
+        else
+          stat.record_apdex_f
+        end
+        # Apdex min and max values should be initialized to the
+        # current apdex_t
+        stat.min_call_time = apdex_t
+        stat.max_call_time = apdex_t
+      end
+
+      private
+
+      def process_cpu
+        return nil if defined? JRuby
+        p = Process.times
+        p.stime + p.utime
+      end
+
+      def jruby_cpu_time # :nodoc:
+        return nil unless @@java_classes_loaded
+        threadMBean = ManagementFactory.getThreadMXBean()
+        java_utime = threadMBean.getCurrentThreadUserTime()  # ns
+        -1 == java_utime ? 0.0 : java_utime/1e9
+      end
+
+      def agent
+        NewRelic::Agent.instance
+      end
+
+      def transaction_sampler
+        agent.transaction_sampler
+      end
+
+      def sql_sampler
+        agent.sql_sampler
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction_info.rb

@@ -7,25 +7,15 @@ require 'erb'
 module NewRelic
   module Agent
     class TransactionInfo
-      DEFAULT_TRANSACTION_NAME = '(unknown)'
 
-      attr_accessor :token, :capture_deep_tt
-      attr_writer :transaction_name
+      attr_accessor :token, :capture_deep_tt, :request, :transaction
       attr_reader :start_time
 
       def initialize
         @guid = ""
-        @transaction_name = nil
         @start_time = Time.now
         @ignore_end_user = false
-      end
-
-      def transaction_name_set?
-        !@transaction_name.nil?
-      end
-
-      def transaction_name
-        @transaction_name || DEFAULT_TRANSACTION_NAME
+        @transaction = Transaction.current
       end
 
       def force_persist_sample?(sample)
@@ -58,7 +48,7 @@ module NewRelic
 
       def apdex_t
         (Agent.config[:web_transactions_apdex] &&
-         Agent.config[:web_transactions_apdex][@transaction_name]) ||
+         Agent.config[:web_transactions_apdex][@transaction.name]) ||
           Agent.config[:apdex_t]
       end
 
@@ -89,6 +79,8 @@ module NewRelic
         clear
         instance = get
         instance.token = get_token(request)
+        instance.request = request
+        instance.transaction = Transaction.current
       end
 
       def self.get_token(request)

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -5,7 +5,7 @@
 require 'new_relic/collection_helper'
 require 'new_relic/transaction_sample'
 require 'new_relic/control'
-require 'new_relic/agent/instrumentation/metric_frame'
+require 'new_relic/agent/transaction'
 module NewRelic
   module Agent
     # a builder is created with every sampled transaction, to dynamically
@@ -27,20 +27,20 @@ module NewRelic
       end
 
       def ignored?
-        @ignore || @sample.params[:path].nil?
+        @ignore
       end
 
       def ignore_transaction
         @ignore = true
       end
-      
+
       def segment_limit
         Agent.config[:'transaction_tracer.limit_segments']
       end
 
-      def trace_entry(metric_name, time)
+      def trace_entry(time)
         if @sample.count_segments < segment_limit()
-          segment = @sample.create_segment(time.to_f - @sample_start, metric_name)
+          segment = @sample.create_segment(time.to_f - @sample_start)
           @current_segment.add_called_segment(segment)
           @current_segment = segment
           if @sample.count_segments == segment_limit()
@@ -52,14 +52,12 @@ module NewRelic
 
       def trace_exit(metric_name, time)
         return unless @sample.count_segments < segment_limit()
-        if metric_name != @current_segment.metric_name
-          fail "unbalanced entry/exit: #{metric_name} != #{@current_segment.metric_name}"
-        end
+        @current_segment.metric_name = metric_name
         @current_segment.end_trace(time.to_f - @sample_start)
         @current_segment = @current_segment.parent_segment
       end
 
-      def finish_trace(time=Time.now.to_f)
+      def finish_trace(time=Time.now.to_f, custom_params={})
         # This should never get called twice, but in a rare case that we can't reproduce in house it does.
         # log forensics and return gracefully
         if @sample.frozen?
@@ -68,7 +66,7 @@ module NewRelic
         end
         @sample.root_segment.end_trace(time.to_f - @sample_start)
         @sample.params[:custom_params] ||= {}
-        @sample.params[:custom_params].merge!(normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters))
+        @sample.params[:custom_params].merge!(normalize_params(custom_params))
 
         txn_info = NewRelic::Agent::TransactionInfo.get
         @sample.force_persist = txn_info.force_persist_sample?(sample)
@@ -97,9 +95,7 @@ module NewRelic
         @sample.profile = profile
       end
 
-      def set_transaction_info(path, uri, params)
-        @sample.params[:path] = path
-
+      def set_transaction_info(uri, params)
         if Agent.config[:capture_params]
           params = normalize_params params
 
@@ -110,15 +106,12 @@ module NewRelic
         @sample.params[:uri] ||= uri || params[:uri]
       end
 
-      def set_transaction_cpu_time(cpu_time)
-        @sample.params[:custom_params] ||= {}
-        @sample.params[:custom_params][:cpu_time] = cpu_time
+      def set_transaction_name(name)
+        @sample.params[:path] = name
       end
 
-      # Set the metric name of the current segment to +new_name+ if 
-      def rename_current_segment( new_name )
-        return unless @sample.count_segments < segment_limit()
-        @current_segment.metric_name = new_name
+      def set_transaction_cpu_time(cpu_time)
+        @sample.set_custom_param(:cpu_time, cpu_time)
       end
 
       def sample