newrelic_rpm 3.7.2.195 → 3.7.3.199

data/lib/new_relic/agent/sampler_collection.rb

@@ -9,7 +9,8 @@ module NewRelic
 
       def initialize(event_listener)
         @samplers = []
-        event_listener.subscribe(:before_harvest) { poll_samplers }
+        @event_listener = event_listener
+        @event_listener.subscribe(:before_harvest) { poll_samplers }
       end
 
       def each(&blk)
@@ -39,7 +40,9 @@ module NewRelic
       def add_sampler(sampler_class)
         if sampler_class.supported_on_this_platform?
           if !sampler_class_registered?(sampler_class)
-            @samplers << sampler_class.new
+            sampler = sampler_class.new
+            sampler.setup_events(@event_listener) if sampler.respond_to?(:setup_events)
+            @samplers << sampler
             ::NewRelic::Agent.logger.debug("Registered #{sampler_class.name} for harvest time sampling.")
           else
             ::NewRelic::Agent.logger.warn("Ignoring addition of #{sampler_class.name} because it is already registered.")

data/lib/new_relic/agent/shim_agent.rb

@@ -22,7 +22,7 @@ module NewRelic
       def after_fork *args; end
       def start *args; end
       def shutdown *args; end
-      def merge_data_from *args; end
+      def merge_data_for_endpoint *args; end
       def push_trace_execution_flag *args; end
       def pop_trace_execution_flag *args; end
       def browser_timing_header; "" end

data/lib/new_relic/agent/transaction.rb

@@ -21,9 +21,14 @@ module NewRelic
       # 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
+      attr_reader :guid
       attr_reader :stats_hash
 
+      # Populated with the trace sample once this transaction is completed.
+      attr_reader :transaction_trace
+
       # 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.
@@ -102,6 +107,7 @@ module NewRelic
         @request = options[:request]
         @exceptions = {}
         @stats_hash = StatsHash.new
+        @guid = generate_guid
         TransactionState.get.transaction = self
       end
 
@@ -196,7 +202,6 @@ module NewRelic
           end
           @transaction_trace = transaction_sampler.notice_scope_empty(self, Time.now, gc_time)
           sql_sampler.notice_scope_empty(@name)
-          overview_metrics = transaction_overview_metrics
         end
 
         record_exceptions
@@ -204,23 +209,42 @@ module NewRelic
 
         # these tear everything down so need to be done after merging stats
         if self.root?
-          send_transaction_finished_event(start_time, end_time, overview_metrics)
+          send_transaction_finished_event(start_time, end_time)
           agent.stats_engine.end_transaction
         end
       end
 
-      def send_transaction_finished_event(start_time, end_time, overview_metrics)
+      # This event is fired when the transaction is fully completed. The metric
+      # values and sampler can't be successfully modified from this event.
+      def send_transaction_finished_event(start_time, end_time)
         payload = {
           :name             => @name,
           :type             => @type,
           :start_timestamp  => start_time.to_f,
           :duration         => end_time.to_f - start_time.to_f,
-          :overview_metrics => overview_metrics,
+          :metrics          => @stats_hash,
           :custom_params    => custom_parameters
         }
+        append_guid_to(payload)
+        append_referring_transaction_guid_to(payload)
+
         agent.events.notify(:transaction_finished, payload)
       end
 
+      def append_guid_to(payload)
+        guid = NewRelic::Agent::TransactionState.get.request_guid_for_event
+        if guid
+          payload[:guid] = guid
+        end
+      end
+
+      def append_referring_transaction_guid_to(payload)
+        referring_guid = NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_guid
+        if referring_guid
+          payload[:referring_transaction_guid] = referring_guid
+        end
+      end
+
       def merge_stats_hash
         stats_hash.resolve_scopes!(@name)
         NewRelic::Agent.instance.stats_engine.merge!(stats_hash)
@@ -233,24 +257,6 @@ module NewRelic
         end
       end
 
-      OVERVIEW_SPECS = [
-        [:webDuration,      MetricSpec.new('HttpDispatcher')],
-        [:queueDuration,    MetricSpec.new('WebFrontend/QueueTime')],
-        [:externalDuration, MetricSpec.new('External/allWeb')],
-        [:databaseDuration, MetricSpec.new('ActiveRecord/all')],
-        [:gcCumulative,     MetricSpec.new("GC/cumulative")],
-        [:memcacheDuration, MetricSpec.new('Memcache/allWeb')]
-      ]
-
-      def transaction_overview_metrics
-        metrics = {}
-        stats = @stats_hash
-        OVERVIEW_SPECS.each do |(dest_key, spec)|
-          metrics[dest_key] = stats[spec].total_call_time if stats.key?(spec)
-        end
-        metrics
-      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
@@ -466,6 +472,19 @@ module NewRelic
       def sql_sampler
         agent.sql_sampler
       end
+
+      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+      GUID_LENGTH = 16
+
+      # generate a random 64 bit uuid
+      def generate_guid
+        guid = ''
+        GUID_LENGTH.times do |a|
+          guid << HEX_DIGITS[rand(16)]
+        end
+        guid
+      end
+
     end
   end
 end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -139,10 +139,6 @@ module NewRelic
         depth
       end
 
-      def set_profile(profile)
-        @sample.profile = profile
-      end
-
       def set_transaction_info(uri, params)
         if Agent.config[:capture_params]
           params = normalize_params params

data/lib/new_relic/agent/transaction_sampler.rb

@@ -119,8 +119,10 @@ module NewRelic
 
         @samples_lock.synchronize do
           @last_sample = last_builder.sample
+          @last_sample.guid = txn.guid
           @last_sample.set_custom_param(:gc_time, gc_time) if gc_time
           store_sample(@last_sample)
+          @last_sample
         end
       end
 
@@ -144,11 +146,6 @@ module NewRelic
         builder.ignore_transaction if builder
       end
 
-      # For developer mode profiling support - delegates to the builder
-      def notice_profile(profile)
-        builder.set_profile(profile) if builder
-      end
-
       # Sets the CPU time used by a transaction, delegates to the builder
       def notice_transaction_cpu_time(cpu_time)
         builder.set_transaction_cpu_time(cpu_time) if builder

data/lib/new_relic/agent/transaction_state.rb

@@ -29,27 +29,40 @@ module NewRelic
       end
 
       # This starts the timer for the transaction.
-      def self.reset(request=nil)
-        self.get.reset(request)
+      def self.reset
+        self.get.reset
+      end
+
+      def self.request=(request)
+        self.get.request = request
       end
 
       def initialize
         @stats_scope_stack = []
       end
 
-      def reset(request)
+      def request=(request)
+        reset unless reset?
+        @request = request
+        @request_token = BrowserToken.get_token(request)
+      end
+
+      def reset
         # We almost always want to use the transaction time, but in case it's
         # not available, we track the last reset. No accessor, as only the
         # TransactionState class should use it.
         @last_reset_time = Time.now
-
-        @transaction = Transaction.current
+        @transaction = nil
         @timings = nil
-
-        @request = request
-        @request_token = BrowserToken.get_token(request)
-        @request_guid = ""
+        @request = nil
+        @request_token = nil
         @request_ignore_enduser = false
+        @is_cross_app_caller = false
+        @referring_transaction_info = nil
+      end
+
+      def reset?
+        @transaction.nil?
       end
 
       def timings
@@ -58,10 +71,29 @@ module NewRelic
 
       # Cross app tracing
       # Because we need values from headers before the transaction actually starts
-      attr_accessor :client_cross_app_id, :referring_transaction_info
+      attr_accessor :client_cross_app_id, :referring_transaction_info, :is_cross_app_caller
+
+      def is_cross_app_caller?
+        @is_cross_app_caller
+      end
+
+      def is_cross_app_callee?
+        referring_transaction_info != nil
+      end
+
+      def request_guid_for_event
+        return nil unless is_cross_app_callee? || is_cross_app_caller? || include_guid?
+        request_guid
+      end
 
       # Request data
-      attr_accessor :request, :request_token, :request_guid, :request_ignore_enduser
+      attr_reader :request
+      attr_accessor :request_token, :request_ignore_enduser
+
+      def request_guid
+        return nil unless transaction
+        transaction.guid
+      end
 
       def request_guid_to_include
         return "" unless include_guid?

data/lib/new_relic/agent/vm.rb

@@ -0,0 +1,32 @@
+# 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/language_support'
+require 'new_relic/agent/vm/mri_vm'
+require 'new_relic/agent/vm/jruby_vm'
+require 'new_relic/agent/vm/rubinius_vm'
+
+module NewRelic
+  module Agent
+    module VM
+      def self.snapshot
+        vm.snapshot
+      end
+
+      def self.vm
+        @vm ||= create_vm
+      end
+
+      def self.create_vm
+        if NewRelic::LanguageSupport.using_engine?('jruby')
+          JRubyVM.new
+        elsif NewRelic::LanguageSupport.using_engine?('rbx')
+          RubiniusVM.new
+        else
+          MriVM.new
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/vm/jruby_vm.rb

@@ -0,0 +1,40 @@
+# 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 'thread'
+require 'new_relic/agent/vm/snapshot'
+
+module NewRelic
+  module Agent
+    module VM
+      class JRubyVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          if supports?(:gc_runs)
+            gc_stats = GC.stat
+            snap.gc_runs = gc_stats[:count]
+          end
+
+          snap.thread_count = Thread.list.size
+        end
+
+        def supports?(key)
+          case key
+          when :gc_runs
+            RUBY_VERSION >= "1.9.2"
+          when :thread_count
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/vm/monotonic_gc_profiler.rb

@@ -0,0 +1,36 @@
+# 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.
+
+# The GC::Profiler class available on MRI has to be reset periodically to avoid
+# memory "leaking" in the underlying implementation. However, it's a major
+# bummer for how we want to gather those statistics.
+#
+# This class comes to the rescue. It relies on being the only party to reset
+# the underlying GC::Profiler, but otherwise gives us a steadily increasing
+# total time.
+module NewRelic
+  module Agent
+    module VM
+      class MonotonicGCProfiler
+        def initialize
+          @total_time = 0
+        end
+
+        class ProfilerNotEnabledError < StandardError
+          def initialize
+            super("total_time is not available if GC::Profiler isn't enabled")
+          end
+        end
+
+        def total_time
+          raise ProfilerNotEnabledError.new unless NewRelic::LanguageSupport.gc_profiler_enabled?
+
+          @total_time += ::GC::Profiler.total_time
+          ::GC::Profiler.clear
+          @total_time
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/vm/mri_vm.rb

@@ -0,0 +1,86 @@
+# 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 'thread'
+require 'new_relic/agent/vm/snapshot'
+
+module NewRelic
+  module Agent
+    module VM
+      class MriVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          gather_gc_stats(snap)
+          gather_ruby_vm_stats(snap)
+          gather_thread_stats(snap)
+        end
+
+        def gather_gc_stats(snap)
+          if supports?(:gc_runs)
+            snap.gc_runs = GC.count
+          end
+
+          if GC.respond_to?(:stat)
+            gc_stats = GC.stat
+            snap.total_allocated_object = gc_stats[:total_allocated_object]
+            snap.major_gc_count = gc_stats[:major_gc_count]
+            snap.minor_gc_count = gc_stats[:minor_gc_count]
+            snap.heap_live = gc_stats[:heap_live_slot] || gc_stats[:heap_live_num]
+            snap.heap_free = gc_stats[:heap_free_slot] || gc_stats[:heap_free_num]
+          end
+        end
+
+        def gather_gc_time(snap)
+          if supports?(:gc_total_time)
+            snap.gc_total_time = NewRelic::Agent.instance.monotonic_gc_profiler.total_time
+          end
+        end
+
+        def gather_ruby_vm_stats(snap)
+          if supports?(:method_cache_invalidations)
+            vm_stats = RubyVM.stat
+            snap.method_cache_invalidations = vm_stats[:global_method_state]
+            snap.constant_cache_invalidations = vm_stats[:global_constant_state]
+          end
+        end
+
+        def gather_thread_stats(snap)
+          snap.thread_count = Thread.list.size
+        end
+
+        def supports?(key)
+          case key
+          when :gc_runs
+            RUBY_VERSION >= '1.9.2'
+          when :gc_total_time
+            NewRelic::LanguageSupport.gc_profiler_enabled?
+          when :total_allocated_object
+            RUBY_VERSION >= '2.0.0'
+          when :major_gc_count
+            RUBY_VERSION >= '2.1.0'
+          when :minor_gc_count
+            RUBY_VERSION >= '2.1.0'
+          when :heap_live
+            RUBY_VERSION >= '1.9.3'
+          when :heap_free
+            RUBY_VERSION >= '1.9.3'
+          when :method_cache_invalidations
+            RUBY_VERSION >= '2.1.0'
+          when :constant_cache_invalidations
+            RUBY_VERSION >= '2.1.0'
+          when :thread_count
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end