ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

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

@@ -1,54 +1,49 @@
+require 'new_relic/language_support'
+
 module NewRelic
   module Agent
     class StatsEngine
+      # Handles methods related to actual Metric collection
       module MetricStats
-        class SynchronizedHash < Hash
-          def initialize(*args)
-            @mutex = Mutex.new
-            super
+        # A simple mutex-synchronized hash to make sure our statistics
+        # are internally consistent even in truly-threaded rubies like JRuby
+        class SynchronizedHash < ::Hash
+          include NewRelic::LanguageSupport::SynchronizedHash
+          
+          def initialize
+            @lock = Mutex.new
           end
-
+          
           def []=(*args)
-            @mutex.synchronize {
-              super
-            }
-          end
-
-          def [](*args)
-            @mutex.synchronize {
-              super
-            }
+            @lock.synchronize { super }
           end
 
           def clear(*args)
-            @mutex.synchronize {
-              super
-            }
+            @lock.synchronize { super }
           end
 
           def delete(*args)
-            @mutex.synchronize {
-              super
-            }
+            @lock.synchronize { super }
           end
 
           def delete_if(*args)
-            @mutex.synchronize {
-              super
-            }
+            @lock.synchronize { super }
           end
         end
-
+        
+        # Returns all of the metric names of all the stats in the engine
         def metrics
           stats_hash.keys.map(&:to_s)
         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
         def get_stats_no_scope(metric_name)
           stats_hash[NewRelic::MetricSpec.new(metric_name, '')] ||= NewRelic::MethodTraceStats.new
         end
 
         # This version allows a caller to pass a stat class to use
-        #
         def get_custom_stats(metric_name, stat_class)
           stats_hash[NewRelic::MetricSpec.new(metric_name)] ||= stat_class.new
         end
@@ -69,13 +64,21 @@ module NewRelic
           end
           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
         def lookup_stats(metric_name, scope_name = '')
           stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)]
         end
-
+        
+        # This module was extracted from the harvest method and should
+        # be refactored
         module Harvest
-
+          
+          # merge data from previous harvests into this stats engine -
+          # takes into account the case where there are new stats for
+          # that metric, and the case where there is no current data
+          # for that metric
           def merge_data(metric_data_hash)
             metric_data_hash.each do |metric_spec, metric_data|
               new_data = lookup_stats(metric_spec.name, metric_spec.scope)
@@ -172,7 +175,9 @@ module NewRelic
         def reset_stats
           stats_hash.values.each { |s| s.reset }
         end
-
+        
+        # returns a memoized SynchronizedHash that holds the actual
+        # instances of Stats keyed off their MetricName
         def stats_hash
           @stats_hash ||= SynchronizedHash.new
         end

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

@@ -6,14 +6,20 @@ module Agent
       def add_harvest_sampler(*args); end
       def start_sampler_thread(*args); end
     end
-
+    
+    # Contains statistics engine extensions to support the concept of samplers
     module Samplers
 
       # By default a sampler polls on harvest time, once a minute.  However you can
       # override #use_harvest_sampler? to return false and it will sample
       # every POLL_PERIOD seconds on a background thread.
       POLL_PERIOD = 20
-
+      
+      # starts the sampler thread which runs periodically, rather than
+      # at harvest time. This is deprecated, and should not actually
+      # be used - mo threads mo problems
+      #
+      # returns unless there are actually periodic samplers to run
       def start_sampler_thread
 
         return if @sampler_thread && @sampler_thread.alive?
@@ -41,7 +47,7 @@ module Agent
       end
 
       def log_added_sampler(type, sampler)
-        log.debug "Adding #{type} sampler: #{sampler.inspect}"
+        log.debug "Adding #{type} sampler: #{sampler.id}"
       end
 
       public
@@ -68,7 +74,7 @@ module Agent
           begin
             sampled_item.poll
             false # it's okay.  don't delete it.
-          rescue Exception => e
+          rescue => e
             log.error "Removing #{sampled_item} from list"
             log.error e
             log.debug e.backtrace.to_s

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

@@ -1,10 +1,9 @@
+# -*- coding: utf-8 -*-
 module NewRelic
 module Agent
   class StatsEngine
-
-    # Defines methods that stub out the stats engine methods
-    # when the agent is disabled
-
+    # A simple stack element that tracks the current name and length
+    # of the executing stack
     class ScopeStackElement
       attr_reader :name, :deduct_call_time_from_parent
       attr_accessor :children_time
@@ -14,8 +13,13 @@ module Agent
         @children_time = 0
       end
     end
-
+    
+    # Handles pushing and popping elements onto an internal stack that
+    # tracks where time should be allocated in Transaction Traces
     module Transactions
+      
+      # Defines methods that stub out the stats engine methods
+      # when the agent is disabled
       module Shim # :nodoc:
         def start_transaction(*args); end
         def end_transaction; end
@@ -25,36 +29,32 @@ module Agent
         def scope_name; end
         def pop_scope(*args); end
       end
-
+      
+      # add a new transaction sampler, unless we're currently in a
+      # transaction (then we fail)
       def transaction_sampler= sampler
         fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
         @transaction_sampler = sampler
       end
-
+      
+      # removes a transaction sampler
       def remove_transaction_sampler(l)
         @transaction_sampler = nil
       end
-
+      
+      # Pushes a scope onto the transaction stack - this generates a
+      # TransactionSample::Segment at the end of transaction execution
       def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)
-
         stack = scope_stack
-        if collecting_gc?
-          if stack.empty?
-            # reset the gc time so we only include gc time spent during this call
-            @last_gc_timestamp = gc_time
-            @last_gc_count = gc_collections
-          else
-            capture_gc_time
-          end
-        end
         @transaction_sampler.notice_push_scope metric, time if @transaction_sampler
         scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
         stack.push scope
         scope
       end
-
+      
+      # Pops a scope off the transaction stack - this updates the
+      # transaction sampler that we've finished execution of a traced method
       def pop_scope(expected_scope, duration, time=Time.now.to_f)
-        capture_gc_time if collecting_gc?
         stack = scope_stack
         scope = stack.pop
         fail "unbalanced pop from blame stack, got #{scope ? scope.name : 'nil'}, expected #{expected_scope ? expected_scope.name : 'nil'}" if scope != expected_scope
@@ -69,7 +69,8 @@ module Agent
         @transaction_sampler.notice_pop_scope(scope.name, time) if @transaction_sampler
         scope
       end
-
+      
+      # Returns the latest ScopeStackElement
       def peek_scope
         scope_stack.last
       end
@@ -84,9 +85,9 @@ module Agent
       # via controller actions
       def scope_name=(transaction)
         Thread::current[:newrelic_scope_name] = transaction
-        Thread::current[:newrelic_most_recent_transaction] = transaction
       end
-
+      
+      # Returns the current scope name from the thread local
       def scope_name
         Thread::current[:newrelic_scope_name]
       end
@@ -95,6 +96,7 @@ module Agent
       def start_transaction(name = nil)
         Thread::current[:newrelic_scope_stack] ||= []
         self.scope_name = name if name
+        GCProfiler.init
       end
 
       # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
@@ -102,6 +104,7 @@ module Agent
       # and is ignored.
       #
       def end_transaction
+        GCProfiler.capture
         stack = scope_stack
 
         if stack && stack.empty?
@@ -111,73 +114,11 @@ module Agent
       end
 
       private
-
-      # Make sure we don't do this in a multi-threaded environment
-      def collecting_gc?
-        if !defined?(@@collecting_gc)
-          @@collecting_gc = false
-          if !NewRelic::Control.instance.multi_threaded?
-            @@collecting_gc = true if GC.respond_to?(:time) && GC.respond_to?(:collections) # 1.8.x
-            @@collecting_gc = true if defined?(GC::Profiler) && GC::Profiler.enabled? # 1.9.2
-          end
-        end
-        @@collecting_gc
-      end
-
-      # The total number of times the garbage collector has run since
-      # profiling was enabled
-      def gc_collections
-        if GC.respond_to?(:count)
-          GC.count
-        elsif GC.respond_to?(:collections)
-          GC.collections
-        end
-      end
-
-      # The total amount of time taken by garbage collection since
-      # profiling was enabled
-      def gc_time
-        if GC.respond_to?(:time)
-          GC.time
-        elsif defined?(GC::Profiler) && GC::Profiler.respond_to?(:total_time)
-          # The 1.9 profiler returns a time in usec
-          GC::Profiler.total_time * 1000000.0
-        end
-      end
-
-      # Assumes collecting_gc?
-      def capture_gc_time
-        # Skip this if we are already in this segment
-        return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
-        num_calls = gc_collections - @last_gc_count
-        elapsed = (gc_time - @last_gc_timestamp).to_f
-        @last_gc_timestamp = gc_time
-        @last_gc_count = gc_collections
-        
-        if defined?(GC::Profiler)
-          GC::Profiler.clear
-          @last_gc_timestamp = 0
-        end
-        
-        if num_calls > 0
-          # µs to seconds
-          elapsed = elapsed / 1000000.0
-          # Allocate the GC time to a scope as if the GC just ended
-          # right now.
-          time = Time.now.to_f
-          gc_scope = push_scope("GC/cumulative", time - elapsed)
-          # GC stats are collected into a blamed metric which allows
-          # us to show the stats controller by controller
-          gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)
-          gc_stats.record_multiple_data_points(elapsed, num_calls)
-          pop_scope(gc_scope, elapsed, time)
-        end
-      end
-
+      
+      # Returns the current scope stack, memoized to a thread local variable
       def scope_stack
         Thread::current[:newrelic_scope_stack] ||= []
       end
-
     end
   end
 end

data/lib/new_relic/agent/transaction_info.rb

@@ -0,0 +1,74 @@
+require 'erb'
+
+module NewRelic
+  module Agent
+    class TransactionInfo
+
+      attr_accessor :token, :capture_deep_tt, :transaction_name
+      attr_reader :start_time
+
+      def initialize
+        @guid = ""
+        @transaction_name = "(unknown)"
+        @start_time = Time.now
+      end
+
+      def force_persist_sample?(sample)
+        token && sample.duration > NewRelic::Control.instance.apdex_t
+      end
+
+      def include_guid?
+        token && duration > NewRelic::Control.instance.apdex_t
+      end
+
+      def guid
+        @guid
+      end
+
+      def guid=(value)
+        @guid = value
+      end
+
+      def duration
+        Time.now - start_time
+      end
+
+      def self.get()
+        Thread.current[:newrelic_transaction_info] ||= TransactionInfo.new
+      end
+
+      def self.set(instance)
+        Thread.current[:newrelic_transaction_info] = instance
+      end
+
+      def self.clear
+        Thread.current[:newrelic_transaction_info] = nil
+      end
+
+      # clears any existing transaction info object and initializes a new one.
+      # This starts the timer for the transaction.
+      def self.reset(request=nil)
+        clear
+        instance = get
+        instance.token = get_token(request)
+      end
+
+      def self.get_token(request)
+        return nil unless request
+        
+        agent_flag = request.cookies['NRAGENT']
+        if agent_flag
+          s = agent_flag.split("=")
+          if s.length == 2
+            if s[0] == "tk" && s[1]
+              ERB::Util.h(s[1])
+            end
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -9,6 +9,7 @@ module NewRelic
     # accessed by any other thread so no need for synchronization.
     class TransactionSampleBuilder
       attr_reader :current_segment, :sample
+      attr_accessor :segment_limit
 
       include NewRelic::CollectionHelper
 
@@ -16,24 +17,36 @@ module NewRelic
         @sample = NewRelic::TransactionSample.new(time.to_f)
         @sample_start = time.to_f
         @current_segment = @sample.root_segment
+        @segment_limit = NewRelic::Control.instance.fetch('transaction_tracer', {}) \
+          .fetch('limit_segments', 4000)
       end
 
       def sample_id
         @sample.sample_id
       end
+      
       def ignored?
         @ignore || @sample.params[:path].nil?
       end
+      
       def ignore_transaction
         @ignore = true
       end
+      
       def trace_entry(metric_name, time)
-        segment = @sample.create_segment(time.to_f - @sample_start, metric_name)
-        @current_segment.add_called_segment(segment)
-        @current_segment = segment
+        if @sample.count_segments < @segment_limit
+          segment = @sample.create_segment(time.to_f - @sample_start, metric_name)
+          @current_segment.add_called_segment(segment)
+          @current_segment = segment
+          if @sample.count_segments == @segment_limit
+            NewRelic::Control.instance.log.debug("Segment limit of #{@segment_limit} reached, ceasing collection.")
+          end
+          @current_segment
+        end
       end
 
       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
@@ -51,6 +64,8 @@ module NewRelic
         end
         @sample.root_segment.end_trace(time.to_f - @sample_start)
         @sample.params[:custom_params] = normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters)
+        
+        @sample.force_persist = NewRelic::Agent::TransactionInfo.get.force_persist_sample?(sample)
         @sample.freeze
         @current_segment = nil
       end