newrelic_rpm 4.0.0.332 → 4.8.0.341

data/lib/conditional_vendored_metric_parser.rb

@@ -1,9 +0,0 @@
-# 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.
-
-unless defined?(NewRelic) && defined?(NewRelic::MetricParser)
-  vendored_metric_parser = File.expand_path('../../vendor/gems/metric_parser-0.1.0.pre1/lib/', __FILE__)
-  $:.unshift vendored_metric_parser unless $:.include?(vendored_metric_parser)
-  require 'metric_parser'
-end

data/lib/new_relic/agent/aws_info.rb

@@ -1,90 +0,0 @@
-# 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.
-
-module NewRelic
-  module Agent
-    class AWSInfo
-
-      class ResponseError < StandardError; end
-
-      attr_reader :instance_type, :instance_id, :availability_zone
-
-      def initialize
-        handle_remote_calls do
-          @instance_type = remote_fetch('instance-type')
-          @instance_id = remote_fetch('instance-id')
-          @availability_zone = remote_fetch('placement/availability-zone')
-        end
-      end
-
-      def loaded?
-        instance_type && instance_id && availability_zone
-      end
-
-      def to_collector_hash
-        {
-          :id => instance_id,
-          :type => instance_type,
-          :zone => availability_zone
-        }
-      end
-
-      private
-
-      def reset
-        @instance_type = @instance_id = @availability_zone = nil
-      end
-
-      REMOTE_DATA_VALID_CHARS = /^[0-9a-zA-Z_ .\/-]$/.freeze
-      INSTANCE_HOST = '169.254.169.254'
-      API_VERSION   = '2008-02-01'
-
-      def remote_fetch(remote_key)
-        uri = URI("http://#{INSTANCE_HOST}/#{API_VERSION}/meta-data/#{remote_key}")
-        response = Net::HTTP::get(uri)
-
-        data = filter_remote_data(response)
-
-        unless data
-          NewRelic::Agent.increment_metric('Supportability/utilization/aws/error')
-          raise ResponseError, "Fetching instance metadata for #{remote_key.inspect} returned invalid data: #{response.inspect}"
-        end
-
-        data
-      end
-
-      def handle_remote_calls
-        begin
-          Timeout::timeout(1) do
-            yield
-          end
-        rescue Timeout::Error
-          handle_error "UtilizationData timed out fetching remote keys."
-        rescue StandardError => e
-          handle_error "UtilizationData encountered error fetching remote keys: #{e.message}"
-        end
-      end
-
-      def handle_error(*messages)
-        NewRelic::Agent.logger.debug(*messages)
-        reset
-      end
-
-      def filter_remote_data(data_str)
-        return nil unless data_str.kind_of?(String)
-        return nil unless data_str.bytesize <= 255
-
-        data_str.each_char do |ch|
-          next if ch =~ REMOTE_DATA_VALID_CHARS
-          code_point = ch[0].ord # this works in Ruby 1.8.7 - 2.1.2
-          next if code_point >= 0x80
-
-          return nil # it's in neither set of valid characters
-        end
-
-        data_str
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/rubyprof.rb

@@ -1,26 +0,0 @@
-# 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.
-
-DependencyDetection.defer do
-  named :rubyprof
-
-  depends_on do
-    defined?(::RubyProf) && defined?(::NewRelic::Rack::DeveloperMode) && ::NewRelic::Agent.config[:developer_mode]
-  end
-
-  executes do
-    NewRelic::Agent.instance.events.subscribe(:start_transaction) do
-      if NewRelic::Rack::DeveloperMode.profiling_enabled?
-        ::RubyProf.start
-      end
-    end
-
-    NewRelic::Agent.instance.events.subscribe(:transaction_finished) do
-      if NewRelic::Rack::DeveloperMode.profiling_enabled?
-        trace = NewRelic::Agent::Transaction.tl_current.transaction_trace
-        trace.profile = ::RubyProf.stop
-      end
-    end
-  end
-end

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

@@ -1,188 +0,0 @@
-# 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'
-
-module NewRelic
-  module Agent
-    # @api public
-    class StatsEngine
-      # Handles methods related to actual Metric collection
-      # @api public
-      module MetricStats
-        SCOPE_PLACEHOLDER = '__SCOPE__'.freeze
-
-        # Update the unscoped metrics given in metric_names.
-        # metric_names may be either a single name, or an array of names.
-        #
-        # 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 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
-
-        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, aux, &blk)
-            end
-          end
-        end
-
-        # Like tl_record_unscoped_metrics, but records a scoped metric as well.
-        #
-        # 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 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_and_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(specs, value, aux, &blk)
-            end
-          end
-        end
-
-        # Helper for recording a straight value into the count
-        def tl_record_supportability_metric_count(metric, value)
-          real_name = "Supportability/#{metric}"
-          tl_record_unscoped_metrics(real_name) do |stat|
-            stat.call_count = value
-          end
-        end
-
-        def reset!
-          with_stats_lock do
-            old = @stats_hash
-            @stats_hash = StatsHash.new
-            old
-          end
-        end
-
-        # merge data from previous harvests into this stats engine
-        def merge!(other_stats_hash)
-          with_stats_lock do
-            @stats_hash.merge!(other_stats_hash)
-            @stats_hash
-          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!
-          snapshot = apply_rules_to_metric_data(@metric_rules, snapshot)
-          snapshot.harvested_at = now
-          snapshot
-        end
-
-        def apply_rules_to_metric_data(rules_engine, stats_hash)
-          renamed_stats = NewRelic::Agent::StatsHash.new(stats_hash.started_at)
-          stats_hash.each do |spec, stats|
-            new_name = rules_engine.rename(spec.name)
-            unless new_name.nil?
-              new_spec = NewRelic::MetricSpec.new(new_name, spec.scope)
-              renamed_stats[new_spec].merge!(stats)
-            end
-          end
-          renamed_stats
-        end
-
-        def coerce_to_metric_spec_array(metric_names_or_specs, scope)
-          specs = []
-          Array(metric_names_or_specs).map do |name_or_spec|
-            case name_or_spec
-            when String
-              specs << NewRelic::MetricSpec.new(name_or_spec)
-              specs << NewRelic::MetricSpec.new(name_or_spec, scope) if scope
-            when NewRelic::MetricSpec
-              specs << name_or_spec
-            end
-          end
-          specs
-        end
-
-        # For use by test code only.
-        def clear_stats
-          reset!
-          NewRelic::Agent::BusyCalculator.reset
-        end
-
-        # For use by test code only.
-        def to_h
-          with_stats_lock { @stats_hash.to_h }
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/traced_method_stack.rb

@@ -1,109 +0,0 @@
-# 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.
-
-module NewRelic
-  module Agent
-    class TracedMethodFrame
-      attr_reader :tag
-      attr_accessor :name, :start_time, :children_time
-      def initialize(tag, start_time)
-        @tag = tag
-        @start_time = start_time
-        @children_time = 0
-      end
-    end
-
-    # TracedMethodStack is responsible for tracking the push and pop of methods
-    # that we are tracing, notifying the transaction sampler, and calculating
-    # exclusive time when a method is complete. This is allowed whether a
-    # transaction is in progress not.
-    class TracedMethodStack
-      def initialize
-        @stack = []
-      end
-
-      # Pushes a frame onto the transaction stack - this generates a
-      # Agent::Transaction::TraceNode at the end of transaction execution.
-      #
-      # The generated node won't be named until pop_frame is called.
-      #
-      # +tag+ should be a Symbol, and is only for debugging purposes to
-      # identify this frame if the stack gets corrupted.
-      def push_frame(state, tag, time = Time.now.to_f)
-        transaction_sampler.notice_push_frame(state, time) if sampler_enabled?
-        frame = TracedMethodFrame.new(tag, time)
-        @stack.push frame
-        frame
-      end
-
-      def push_segment state, segment
-        transaction_sampler.notice_push_frame(state, segment.start_time) if sampler_enabled?
-        @stack.push segment
-        segment
-      end
-
-      # Pops a frame off the transaction stack - this updates the transaction
-      # sampler that we've finished execution of a traced method.
-      #
-      # +expected_frame+ should be TracedMethodFrame from the corresponding
-      # push_frame call.
-      #
-      # +name+ will be applied to the generated transaction trace node.
-      def pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent=true)
-        frame = fetch_matching_frame(expected_frame)
-
-        note_children_time(frame, time, deduct_call_time_from_parent)
-
-        transaction_sampler.notice_pop_frame(state, name, time) if sampler_enabled?
-        frame.name = name if frame.is_a? TracedMethodFrame
-        frame
-      end
-
-      def fetch_matching_frame(expected_frame)
-        while frame = @stack.pop
-          if frame == expected_frame
-            return frame
-          else
-            NewRelic::Agent.logger.info("Unexpected frame in traced method stack: #{frame.inspect} expected to be #{expected_frame.inspect}")
-            NewRelic::Agent.logger.debug do
-              ["Backtrace for unexpected frame: ", caller.join("\n")]
-            end
-          end
-        end
-
-        raise "Frame not found in blame stack: #{expected_frame.inspect}"
-      end
-
-      def note_children_time(frame, time, deduct_call_time_from_parent)
-        if !@stack.empty?
-          if deduct_call_time_from_parent
-            @stack.last.children_time += (time - frame.start_time)
-          else
-            @stack.last.children_time += frame.children_time
-          end
-        end
-      end
-
-      def sampler_enabled?
-        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
-      end
-
-      def transaction_sampler
-        Agent.instance.transaction_sampler
-      end
-
-      def clear
-        @stack.clear
-      end
-
-      def empty?
-        @stack.empty?
-      end
-
-      def last
-        @stack.last
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# 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/transaction_sample_buffer'
-
-module NewRelic
-  module Agent
-    class Transaction
-      class DeveloperModeSampleBuffer < TransactionSampleBuffer
-
-        CAPACITY = 100
-
-        def capacity
-          max_capacity
-        end
-
-        # Dev mode is allowed more than the typical upper limit.
-        # Sidestep normal cap by overriding max_capacity.
-        def max_capacity
-          CAPACITY
-        end
-
-        def harvest_samples
-          NO_SAMPLES
-        end
-
-        def enabled?
-          Agent.config[:developer_mode]
-        end
-
-        # Truncate to the last capacity samples we've received
-        def truncate_samples
-          @samples = @samples.last(capacity)
-        end
-
-        # We don't hold onto previously trapped transactions on harvest
-        # We've already got all the traces we want, thank you!
-        def store_previous(*)
-        end
-
-        # Captures the stack trace for a node
-        # This is expensive and not for production mode
-        def visit_node(node)
-          return unless enabled? && node
-
-          trace = strip_newrelic_frames(caller)
-          trace = trace.first(40) if trace.length > 40
-          node[:backtrace] = trace
-        end
-
-        def strip_newrelic_frames(trace)
-          while trace.first =~/\/lib\/new_relic\/agent\//
-            trace.shift
-          end
-          trace
-        end
-
-      end
-    end
-  end
-end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -1,141 +0,0 @@
-# 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/collection_helper'
-require 'new_relic/agent/transaction'
-require 'new_relic/agent/transaction/trace'
-
-module NewRelic
-  module Agent
-    # a builder is created with every sampled transaction, to dynamically
-    # generate the sampled data.  It is a thread-local object, and is not
-    # accessed by any other thread so no need for synchronization.
-    #
-    # @api private
-    class TransactionSampleBuilder
-
-      # Once we hit the TT node limit, we use this class to hold our place in
-      # the tree so that we can still get accurate names and times on the
-      # nodes we've already created. The placeholder node keeps a
-      # depth counter that's incremented on each node entry, and decremented
-      # on exit, until it reaches zero, when we throw the placeholder away.
-      # There should only ever be zero or one placeholder node at a time.
-      #
-      # @api private
-      class PlaceholderNode
-        attr_reader :parent_node
-        attr_accessor :depth
-
-        def initialize(parent_node)
-          @parent_node = parent_node
-          @depth = 1
-        end
-
-        # No-op - some clients expect to be able to use these to read/write
-        # params on TT nodes.
-        def [](key); end
-        def []=(key, value); end
-
-        # Stubbed out in case clients try to touch params directly.
-        def params; {}; end
-        def params=; end
-      end
-
-      attr_reader :current_node, :sample
-
-      include NewRelic::CollectionHelper
-
-      def initialize(time=Time.now)
-        @sample = NewRelic::Agent::Transaction::Trace.new(time.to_f)
-        @sample_start = time.to_f
-        @current_node = @sample.root_node
-      end
-
-      def sample_id
-        @sample.sample_id
-      end
-
-      def ignored?
-        @ignore
-      end
-
-      def ignore_transaction
-        @ignore = true
-      end
-
-      def node_limit
-        Agent.config[:'transaction_tracer.limit_segments']
-      end
-
-      def trace_entry(time)
-        if @sample.count_nodes < node_limit
-          node = @sample.create_node(time.to_f - @sample_start)
-          @current_node.add_called_node(node)
-          @current_node = node
-          if @sample.count_nodes == node_limit()
-            ::NewRelic::Agent.logger.debug("Node limit of #{node_limit} reached, ceasing collection.")
-          end
-        else
-          if @current_node.is_a?(PlaceholderNode)
-            @current_node.depth += 1
-          else
-            @current_node = PlaceholderNode.new(@current_node)
-          end
-        end
-        @current_node
-      end
-
-      def trace_exit(metric_name, time)
-        if @current_node.is_a?(PlaceholderNode)
-          @current_node.depth -= 1
-          if @current_node.depth == 0
-            @current_node = @current_node.parent_node
-          end
-        else
-          @current_node.metric_name = metric_name
-          @current_node.end_trace(time.to_f - @sample_start)
-          @current_node = @current_node.parent_node
-        end
-      end
-
-      def finish_trace(time=Time.now.to_f)
-        # 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.finished
-          ::NewRelic::Agent.logger.error "Unexpected double-finish_trace of Transaction Trace Object: \n#{@sample.to_s}"
-          return
-        end
-        @sample.root_node.end_trace(time.to_f - @sample_start)
-
-        @sample.threshold = transaction_trace_threshold
-        @sample.finished = true
-        @current_node = nil
-      end
-
-      TT_THRESHOLD_KEY = :'transaction_tracer.transaction_threshold'
-
-      def transaction_trace_threshold #THREAD_LOCAL_ACCESS
-        state = TransactionState.tl_get
-        source_class = Agent.config.source(TT_THRESHOLD_KEY).class
-        if source_class == Configuration::DefaultSource && state.current_transaction
-          state.current_transaction.apdex_t * 4
-        else
-          Agent.config[TT_THRESHOLD_KEY]
-        end
-      end
-
-      def scope_depth
-        depth = -1        # have to account for the root
-        current = @current_node
-
-        while(current)
-          depth += 1
-          current = current.parent_node
-        end
-
-        depth
-      end
-    end
-  end
-end

data/lib/new_relic/merbtasks.rb

@@ -1,10 +0,0 @@
-# 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.
-
-namespace :newrelic do
-  desc "Install the developer mode newrelic.yml file"
-  task :default do
-    load File.expand_path(File.join(__FILE__,"..","..","install.rb"))
-  end
-end

data/lib/new_relic/rack/developer_mode/segment_summary.rb

@@ -1,56 +0,0 @@
-# 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.
-
-# summarizes performance data for all calls to segments
-# with the same metric_name
-module NewRelic
-  module Rack
-    class DeveloperMode
-      class SegmentSummary
-        attr_accessor :metric_name, :total_time, :exclusive_time, :call_count, :current_nest_count
-
-        def initialize(metric_name, sample)
-          @metric_name = metric_name
-          @total_time, @exclusive_time, @call_count = 0,0,0
-          @sample = sample
-          @current_nest_count = 0
-        end
-
-        def <<(segment)
-          if metric_name != segment.metric_name
-            raise ArgumentError, "Metric Name Mismatch: #{segment.metric_name} != #{metric_name}"
-          end
-
-          # a nested segment should use the sum of the top level totals
-          @total_time += segment.duration if current_nest_count == 0
-          @exclusive_time += segment.exclusive_duration
-          @call_count += 1
-        end
-
-        def average_time
-          @total_time / @call_count
-        end
-
-        def average_exclusive_time
-          @exclusive_time / @call_count
-        end
-
-        def exclusive_time_percentage
-          return 0 unless @exclusive_time && @sample.duration && @sample.duration > 0
-          @exclusive_time / @sample.duration
-        end
-
-        def total_time_percentage
-          return 0 unless @total_time && @sample.duration && @sample.duration > 0
-          @total_time / @sample.duration
-        end
-
-        def ui_name
-          return @metric_name if @metric_name == 'Remainder'
-          NewRelic::MetricParser::MetricParser.parse(@metric_name).developer_name
-        end
-      end
-    end
-  end
-end