newrelic_rpm 3.5.7.59 → 3.5.8.64.beta

data/lib/new_relic/agent/cross_process_monitoring.rb

@@ -1,187 +0,0 @@
-require 'new_relic/rack/agent_hooks'
-require 'new_relic/agent/thread'
-
-module NewRelic
-  module Agent
-    class CrossProcessMonitor
-
-      def initialize(events = nil)
-        # When we're starting up for real in the agent, we get passed the events
-        # Other spots can pull from the agent, during startup the agent doesn't exist yet!
-        events ||= Agent.instance.events
-        @trusted_ids = []
-
-        events.subscribe(:finished_configuring) do
-          finish_setup(Agent.config)
-          register_event_listeners
-        end
-      end
-
-      def finish_setup(config)
-        @cross_process_id = config[:cross_process_id]
-        @encoding_key = config[:encoding_key]
-        @encoding_bytes = get_bytes(@encoding_key) unless @encoding_key.nil?
-        @trusted_ids = config[:trusted_account_ids] || []
-      end
-
-      # Expected sequence of events:
-      #   :before_call will save our cross process request id to the thread
-      #   :start_transaction will get called when a transaction starts up
-      #   :after_call will write our response headers/metrics and clean up the thread
-      def register_event_listeners
-        NewRelic::Agent.logger.debug("Wiring up Cross Process monitoring to events after finished configuring")
-
-        events = Agent.instance.events
-        events.subscribe(:before_call) do |env|
-          save_client_cross_process_id(env)
-        end
-
-        events.subscribe(:start_transaction) do |name|
-          set_transaction_custom_parameters
-        end
-
-        events.subscribe(:after_call) do |env, (status_code, headers, body)|
-          insert_response_header(env, headers)
-        end
-
-        events.subscribe(:notice_error) do |_, options|
-          set_error_custom_parameters(options)
-        end
-      end
-
-      # Because we aren't in the right spot when our transaction actually
-      # starts, hold client_cross_process_id we get thread local until then.
-      THREAD_ID_KEY = :newrelic_client_cross_process_id
-
-      def save_client_cross_process_id(request_headers)
-        if should_process_request(request_headers)
-          NewRelic::Agent::AgentThread.current[THREAD_ID_KEY] = decoded_id(request_headers)
-        end
-      end
-
-      def clear_client_cross_process_id
-        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY] = nil
-      end
-
-      def client_cross_process_id
-        NewRelic::Agent::AgentThread.current[THREAD_ID_KEY]
-      end
-
-      def insert_response_header(request_headers, response_headers)
-        unless client_cross_process_id.nil?
-          timings = NewRelic::Agent::BrowserMonitoring.timings
-          content_length = content_length_from_request(request_headers)
-
-          set_response_headers(response_headers, timings, content_length)
-          set_metrics(client_cross_process_id, timings)
-
-          clear_client_cross_process_id
-        end
-      end
-
-      def should_process_request(request_headers)
-        return Agent.config[:'cross_process.enabled'] &&
-            @cross_process_id &&
-            trusts?(request_headers)
-      end
-
-      # Expects an ID of format "12#345", and will only accept that!
-      def trusts?(request)
-        id = decoded_id(request)
-        split_id = id.match(/(\d+)#\d+/)
-        return false if split_id.nil?
-
-        @trusted_ids.include?(split_id.captures.first.to_i)
-      end
-
-      def set_response_headers(response_headers, timings, content_length)
-        response_headers['X-NewRelic-App-Data'] = build_payload(timings, content_length)
-      end
-
-      def build_payload(timings, content_length)
-
-        # FIXME The transaction name might not be properly encoded.  use a json generator
-        # For now we just handle quote characters by dropping them
-        transaction_name = timings.transaction_name.gsub(/["']/, "")
-
-        payload = %[["#{@cross_process_id}","#{transaction_name}",#{timings.queue_time_in_seconds},#{timings.app_time_in_seconds},#{content_length}] ]
-        payload = obfuscate_with_key(payload)
-      end
-
-      def set_transaction_custom_parameters
-        # We expect to get the before call to set the id (if we have it) before
-        # this, and then write our custom parameter when the transaction starts
-        NewRelic::Agent.add_custom_parameters(:client_cross_process_id => client_cross_process_id) unless client_cross_process_id.nil?
-      end
-
-      def set_error_custom_parameters(options)
-        options[:client_cross_process_id] = client_cross_process_id unless client_cross_process_id.nil?
-      end
-
-      def set_metrics(id, timings)
-        metric = NewRelic::Agent.instance.stats_engine.get_stats_no_scope("ClientApplication/#{id}/all")
-        metric.record_data_point(timings.app_time_in_seconds)
-      end
-
-      def obfuscate_with_key(text)
-        Base64.encode64(encode_with_key(text)).chomp
-      end
-
-      def decode_with_key(text)
-        encode_with_key(Base64.decode64(text))
-      end
-
-      NEWRELIC_ID_HEADER_KEYS = %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}
-      CONTENT_LENGTH_HEADER_KEYS = %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH}
-
-      def decoded_id(request)
-        encoded_id = from_headers(request, NEWRELIC_ID_HEADER_KEYS)
-        return "" if encoded_id.nil?
-
-        decode_with_key(encoded_id)
-      end
-
-      def content_length_from_request(request)
-        from_headers(request, CONTENT_LENGTH_HEADER_KEYS) || -1
-      end
-
-
-
-      private
-
-      # Ruby 1.8.6 doesn't support the bytes method on strings.
-      def get_bytes(value)
-        return [] if value.nil?
-
-        bytes = []
-        value.each_byte do |b|
-          bytes << b
-        end
-        bytes
-      end
-
-      def encode_with_key(text)
-        key_bytes =  @encoding_bytes
-
-        encoded = ""
-        index = 0
-        text.each_byte{|byte|
-          encoded.concat((byte ^ key_bytes[index % key_bytes.length].to_i))
-          index+=1
-        }
-        encoded
-      end
-
-      def from_headers(request, try_keys)
-        # For lookups, upcase all our keys on both sides just to be safe
-        upcased_keys = try_keys.map{|k| k.upcase}
-        upcased_keys.each do |header|
-          found_key = request.keys.find { |k| k.upcase == header }
-          return request[found_key] unless found_key.nil?
-        end
-        nil
-      end
-
-    end
-  end
-end

data/lib/new_relic/stats.rb

@@ -1,337 +0,0 @@
-
-module NewRelic
-  module Stats
-    
-    # a stat is absent if its call count equals zero
-    def absent?
-      call_count == 0
-    end
-    
-    # outputs a useful human-readable time given a value in milliseconds
-    def time_str(value_ms)
-      case
-      when value_ms >= 10000
-        "%.1f s" % (value_ms / 1000.0)
-      when value_ms >= 5000
-        "%.2f s" % (value_ms / 1000.0)
-      else
-        "%.0f ms" % value_ms
-      end
-    end
-
-    # makes sure we aren't dividing by zero
-    def checked_calculation(numerator, denominator)
-      if denominator.nil? || denominator == 0
-        0.0
-      else
-        numerator.to_f / denominator
-      end
-    end
-    
-    def average_call_time
-      checked_calculation(total_call_time, call_count)
-    end
-    def average_exclusive_time
-      checked_calculation(total_exclusive_time, call_count)
-    end
-
-    # merge by adding to average response time
-    # - used to compose multiple metrics e.g. dispatcher time + mongrel queue time
-    def sum_merge! (other_stats)
-      Array(other_stats).each do |other|
-        self.sum_attributes(other)
-      end
-      self
-    end
-
-    def sum_attributes(other)
-      update_totals(other)
-      stack_min_max_from(other)
-      self.call_count = [self.call_count, other.call_count].max
-      update_boundaries(other)
-    end
-
-    def stack_min_max_from(other)
-      self.min_call_time += other.min_call_time
-      self.max_call_time += other.max_call_time
-    end
-
-    def update_boundaries(other)
-      self.begin_time = other.begin_time if should_replace_begin_time?(other)
-      self.end_time = other.end_time if should_replace_end_time?(other)
-    end
-
-    def should_replace_end_time?(other)
-      end_time.to_f < other.end_time.to_f
-    end
-
-    def should_replace_begin_time?(other)
-      other.begin_time.to_f < begin_time.to_f || begin_time.to_f == 0.0
-    end
-
-    def update_totals(other)
-      self.total_call_time      += other.total_call_time
-      self.total_exclusive_time += other.total_exclusive_time
-      self.sum_of_squares       += other.sum_of_squares
-    end
-
-    def min_time_less?(other)
-      (other.min_call_time < min_call_time && other.call_count > 0) || call_count == 0
-    end
-
-    def expand_min_max_to(other)
-        self.min_call_time = other.min_call_time if min_time_less?(other)
-        self.max_call_time = other.max_call_time if other.max_call_time > max_call_time
-    end
-
-    def merge_attributes(other)
-      update_totals(other)
-      expand_min_max_to(other)
-      self.call_count += other.call_count
-      update_boundaries(other)
-    end
-
-    def merge!(other_stats)
-      Array(other_stats).each do |other|
-        merge_attributes(other)
-      end
-
-      self
-    end
-
-    def merge(other_stats)
-      stats = self.clone
-      stats.merge!(other_stats)
-    end
-
-
-    def is_reset?
-      call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
-    end
-
-    def reset
-      self.call_count = 0
-      self.total_call_time = 0.0
-      self.total_exclusive_time = 0.0
-      self.min_call_time = 0.0
-      self.max_call_time = 0.0
-      self.sum_of_squares = 0.0
-      self.begin_time = Time.at(0)
-      self.end_time = Time.at(0)
-    end
-
-    def as_percentage_of(other_stats)
-      checked_calculation(total_call_time, other_stats.total_call_time) * 100.0
-    end
-
-    # the stat total_call_time is a percent
-    def as_percentage
-      average_call_time * 100.0
-    end
-
-    def duration
-      end_time ? (end_time - begin_time) : 0.0
-    end
-
-    def midpoint
-      begin_time + (duration/2)
-    end
-    def calls_per_minute
-      checked_calculation(call_count, duration) * 60
-    end
-
-    def total_call_time_per_minute
-      60.0 * time_percentage
-    end
-
-    def standard_deviation
-      return 0 if call_count < 2 || self.sum_of_squares.nil?
-
-      # Convert sum of squares into standard deviation based on
-      # formula for the standard deviation for the entire population
-      x = self.sum_of_squares - (self.call_count * (self.average_value**2))
-      return 0 if x <= 0
-
-      Math.sqrt(x / self.call_count)
-    end
-
-    # returns the time spent in this component as a percentage of the total
-    # time window.
-    def time_percentage
-      checked_calculation(total_call_time, duration)
-    end
-
-    def exclusive_time_percentage
-      checked_calculation(total_exclusive_time, duration)
-    end
-
-    alias average_value average_call_time
-    alias average_response_time average_call_time
-    alias requests_per_minute calls_per_minute
-
-    def to_s
-      summary
-    end
-
-    # Summary string to facilitate testing
-    def summary
-      format = "%m/%d/%y %I:%M%p"
-      "[#{Time.at(begin_time.to_f).utc.strftime(format)} UTC, #{'%2.3fs' % duration.to_f}; #{'%2i' % call_count.to_i} calls #{'%4i' % average_call_time.to_f}s]"
-    end
-
-    # multiply the total time and rate by the given percentage
-    def multiply_by(percentage)
-      self.total_call_time = total_call_time * percentage
-      self.call_count = call_count * percentage
-      self.sum_of_squares = sum_of_squares * percentage
-
-      self
-    end
-
-    # returns s,t,f
-    def get_apdex
-      [@call_count, @total_call_time.to_i, @total_exclusive_time.to_i]
-    end
-
-    def apdex_score
-      s, t, f = get_apdex
-      (s.to_f + (t.to_f / 2)) / (s+t+f).to_f
-    end
-  end
-
-
-  class StatsBase
-    include Stats
-
-    attr_accessor :call_count
-    attr_accessor :min_call_time
-    attr_accessor :max_call_time
-    attr_accessor :total_call_time
-    attr_accessor :total_exclusive_time
-    attr_accessor :sum_of_squares
-
-    def initialize
-      reset
-    end
-
-    def freeze
-      @end_time = Time.now
-      super
-    end
-
-    def to_json(*_)
-      {
-        'call_count'           => call_count.to_i,
-        'min_call_time'        => min_call_time.to_f,
-        'max_call_time'        => max_call_time.to_f,
-        'total_call_time'      => total_call_time.to_f,
-        'total_exclusive_time' => total_exclusive_time.to_f,
-        'sum_of_squares'       => sum_of_squares.to_f
-      }.to_json(*_)
-    end
-
-
-    # In this class, we explicitly don't track begin and end time here, to save space during
-    # cross process serialization via xml.  Still the accessor methods must be provided for merge to work.
-    def begin_time=(t)
-    end
-
-    def end_time=(t)
-    end
-
-    def begin_time
-      0.0
-    end
-
-    def end_time
-      0.0
-    end
-  end
-
-
-  class BasicStats < StatsBase
-  end
-
-  class ApdexStats < StatsBase
-
-    def record_apdex_s
-      @call_count += 1
-    end
-
-    def record_apdex_t
-      @total_call_time += 1
-    end
-
-    def record_apdex_f
-      @total_exclusive_time += 1
-    end
-  end
-
-  # Statistics used to track the performance of traced methods
-  class MethodTraceStats < StatsBase
-
-    alias data_point_count call_count
-
-    # 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
-    def record_data_point(value, exclusive_time = value)
-      @call_count += 1
-      @total_call_time += value
-      @min_call_time = value if value < @min_call_time || @call_count == 1
-      @max_call_time = value if value > @max_call_time
-      @total_exclusive_time += exclusive_time
-
-      @sum_of_squares += (value * value)
-      self
-    end
-
-    alias trace_call record_data_point
-    
-    # Records multiple data points as one method call - this handles
-    # all the aggregation that would be done with multiple
-    # record_data_point calls
-    def record_multiple_data_points(total_value, count=1)
-      return record_data_point(total_value) if count == 1
-      @call_count += count
-      @total_call_time += total_value
-      avg_val = total_value / count
-      @min_call_time = avg_val if avg_val < @min_call_time || @call_count == count
-      @max_call_time = avg_val if avg_val > @max_call_time
-      @total_exclusive_time += total_value
-      @sum_of_squares += (avg_val * avg_val) * count
-      self
-    end
-    
-    # increments the call_count by one
-    def increment_count(value = 1)
-      @call_count += value
-    end
-    
-    # outputs a human-readable version of the MethodTraceStats object
-    def inspect
-      "#<NewRelic::MethodTraceStats #{summary} >"
-    end
-
-  end
-
-  class ScopedMethodTraceStats < MethodTraceStats
-    attr_accessor :unscoped_stats
-    def initialize(unscoped_stats)
-      super()
-      self.unscoped_stats = unscoped_stats
-    end
-    def trace_call(call_time, exclusive_time = call_time)
-      unscoped_stats.trace_call call_time, exclusive_time
-      super call_time, exclusive_time
-    end
-    # Records multiple data points as one method call - this handles
-    # all the aggregation that would be done with multiple
-    # trace_call calls    
-    def record_multiple_data_points(total_value, count=1)
-      unscoped_stats.record_multiple_data_points(total_value, count)
-      super total_value, count
-    end
-  end
-end
-