ghazel-newrelic_rpm 3.1.0.1

data/lib/new_relic/agent/beacon_configuration.rb

@@ -0,0 +1,61 @@
+module NewRelic
+  module Agent
+    class BeaconConfiguration
+      attr_reader :browser_timing_header
+      attr_reader :browser_timing_static_footer
+      attr_reader :application_id
+      attr_reader :browser_monitoring_key
+      attr_reader :beacon
+      attr_reader :rum_enabled
+      attr_reader :license_bytes
+
+      JS_HEADER = "<script type=\"text/javascript\">var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
+
+      def initialize(connect_data)
+        @browser_monitoring_key = connect_data['browser_key']
+        @application_id = connect_data['application_id']
+        @beacon = connect_data['beacon']
+        @rum_enabled = connect_data['rum.enabled']
+        @rum_enabled = true if @rum_enabled.nil?
+        NewRelic::Control.instance.log.warn("Real User Monitoring is disabled for this agent. Edit your configuration to change this.") unless @rum_enabled
+        @browser_timing_header = build_browser_timing_header
+        NewRelic::Control.instance.log.debug("Browser timing header: #{@browser_timing_header.inspect}")
+        @browser_timing_static_footer = build_load_file_js(connect_data)
+        NewRelic::Control.instance.log.debug("Browser timing static footer: #{@browser_timing_static_footer.inspect}")
+      end
+
+      def license_bytes
+        if @license_bytes.nil?
+          @license_bytes = []
+          NewRelic::Control.instance.license_key.each_byte {|byte| @license_bytes << byte}
+        end
+        @license_bytes
+      end
+
+      def build_load_file_js(connect_data)
+        return "" unless connect_data.fetch('rum.load_episodes_file', true)
+
+        episodes_url = connect_data.fetch('episodes_url', '')
+        "(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"#{episodes_url}\";e.type=\"text/javascript\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();"
+      end
+
+      def javascript_header
+        JS_HEADER.dup
+      end
+
+      def build_browser_timing_header
+        return "" if !@rum_enabled
+        return "" if @browser_monitoring_key.nil?
+        
+        value = javascript_header
+        if value.respond_to?(:html_safe)
+          value.html_safe
+        else
+          value
+        end
+      end
+    end
+  end
+end
+
+

data/lib/new_relic/agent/browser_monitoring.rb

@@ -0,0 +1,83 @@
+require 'base64'
+require 'new_relic/agent/beacon_configuration'
+module NewRelic
+  module Agent
+    module BrowserMonitoring
+
+      def browser_timing_header
+        return "" if NewRelic::Agent.instance.beacon_configuration.nil?
+        return "" if !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
+
+        NewRelic::Agent.instance.beacon_configuration.browser_timing_header
+      end
+
+      def browser_timing_footer
+        config = NewRelic::Agent.instance.beacon_configuration
+        return "" if config.nil? || !config.rum_enabled || config.browser_monitoring_key.nil?
+        return "" if !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
+        generate_footer_js
+      end
+
+      private
+
+      def generate_footer_js
+        if browser_monitoring_start_time
+          config = NewRelic::Agent.instance.beacon_configuration
+          application_id = config.application_id
+          beacon = config.beacon
+          license_key = config.browser_monitoring_key
+
+          footer_js_string(beacon, license_key, application_id)
+        else
+          ''
+        end
+      end
+
+      def browser_monitoring_transaction_name
+        Thread.current[:newrelic_most_recent_transaction] || "<unknown>"
+      end
+
+      def browser_monitoring_start_time
+        Thread.current[:newrelic_start_time]
+      end
+
+      def clamp_to_positive(value)
+        return 0.0 if value < 0
+        value
+      end
+
+      def browser_monitoring_app_time
+        clamp_to_positive(((Time.now - browser_monitoring_start_time).to_f * 1000.0).round)
+      end
+
+      def browser_monitoring_queue_time
+        clamp_to_positive((Thread.current[:newrelic_queue_time].to_f * 1000.0).round)
+      end
+
+      def footer_js_string(beacon, license_key, application_id)
+        obfuscated_transaction_name = obfuscate(browser_monitoring_transaction_name)
+        html_safe_if_needed("<script type=\"text/javascript\">#{NewRelic::Agent.instance.beacon_configuration.browser_timing_static_footer}NREUMQ.push([\"nrf2\",\"#{beacon}\",\"#{license_key}\",#{application_id},\"#{obfuscated_transaction_name}\",#{browser_monitoring_queue_time},#{browser_monitoring_app_time},new Date().getTime()])</script>")
+      end
+
+      def html_safe_if_needed(string)
+        if string.respond_to?(:html_safe)
+          string.html_safe
+        else
+          string
+        end
+      end
+
+      def obfuscate(text)
+        obfuscated = ""
+        key_bytes = NewRelic::Agent.instance.beacon_configuration.license_bytes
+        index = 0
+        text.each_byte{|byte|
+          obfuscated.concat((byte ^ key_bytes[index % 13].to_i))
+          index+=1
+        }
+
+        [obfuscated].pack("m0").gsub("\n", '')
+      end
+    end
+  end
+end

data/lib/new_relic/agent/busy_calculator.rb

@@ -0,0 +1,91 @@
+module NewRelic
+  module Agent
+    # This module supports calculation of actual time spent processing requests over the course of
+    # one harvest period.  It's similar to what you would get if you just added up all the
+    # execution times of controller calls, however that will be inaccurate when requests
+    # span the minute boundaries.  This module manages accounting of requests not yet
+    # completed.
+    #
+    # Calls are re-entrant.  All start calls must be paired with finish
+    # calls, or a reset call.
+    module BusyCalculator
+
+      extend self
+
+      # For testability, add accessors:
+      attr_reader :harvest_start, :accumulator
+
+      def dispatcher_start(time)
+        Thread.current[:busy_entries] ||= 0
+        callers = Thread.current[:busy_entries] += 1
+        return if callers > 1
+        @lock.synchronize do
+          @entrypoint_stack.push time
+        end
+      end
+
+      def dispatcher_finish(end_time = Time.now)
+        callers = Thread.current[:busy_entries] -= 1
+        # Ignore nested calls
+        return if callers > 0
+        @lock.synchronize do
+          if @entrypoint_stack.empty?
+            NewRelic::Agent.logger.error("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
+          else
+            @accumulator += (end_time - @entrypoint_stack.pop).to_f
+          end
+        end
+      end
+
+      def busy_count
+        @entrypoint_stack.size
+      end
+
+      # Reset the state of the information accumulated by all threads,
+      # but only reset the recursion counter for this thread.
+      def reset
+        @entrypoint_stack = []
+        Thread.current[:busy_entries] = 0
+        @lock ||= Mutex.new
+        @accumulator = 0
+        @harvest_start = Time.now
+      end
+
+      self.reset
+
+      # Called before uploading to to the server to collect current busy stats.
+      def harvest_busy
+        busy = 0
+        t0 = Time.now
+        @lock.synchronize do
+          busy = accumulator
+          @accumulator = 0
+
+          # Walk through the stack and capture all times up to
+          # now for entrypoints
+          @entrypoint_stack.size.times do |frame|
+            busy += (t0 - @entrypoint_stack[frame]).to_f
+            @entrypoint_stack[frame] = t0
+          end
+
+        end
+
+        busy = 0.0 if busy < 0.0 # don't go below 0%
+
+        time_window = (t0 - harvest_start).to_f
+        time_window = 1.0 if time_window == 0.0  # protect against divide by zero
+
+        busy = busy / time_window
+
+        instance_busy_stats.record_data_point busy
+        @harvest_start = t0
+      end
+      private
+      def instance_busy_stats
+        # Late binding on the Instance/busy stats
+        NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'Instance/Busy'
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/chained_call.rb

@@ -0,0 +1,13 @@
+# This is used to allow obfuscators to be chained.
+
+class NewRelic::ChainedCall
+  def initialize(block1, block2)
+    @block1 = block1
+    @block2 = block2
+  end
+
+  def call(sql)
+    sql = @block1.call(sql)
+    @block2.call(sql)
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,203 @@
+
+module NewRelic
+  module Agent
+  class ErrorCollector
+    include NewRelic::CollectionHelper
+
+    # Defined the methods that need to be stubbed out when the
+    # agent is disabled
+    module Shim #:nodoc:
+      def notice_error(*args); end
+    end
+
+    MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
+
+    attr_accessor :enabled
+    attr_reader :config_enabled
+
+    def initialize
+      @errors = []
+      # lookup of exception class names to ignore.  Hash for fast access
+      @ignore = {}
+      @ignore_filter = nil
+
+      config = NewRelic::Control.instance.fetch('error_collector', {})
+
+      @enabled = @config_enabled = config.fetch('enabled', true)
+      @capture_source = config.fetch('capture_source', true)
+
+      ignore_errors = config.fetch('ignore_errors', "")
+      ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
+      ignore_errors.each { |error| error.strip! }
+      ignore(ignore_errors)
+      @lock = Mutex.new
+    end
+
+    def control
+      NewRelic::Control.instance
+    end
+
+    def ignore_error_filter(&block)
+      if block
+        @ignore_filter = block
+      else
+        @ignore_filter
+      end
+    end
+
+    # errors is an array of Exception Class Names
+    #
+    def ignore(errors)
+      errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
+    end
+
+    module NoticeError
+      def disabled?
+        !@enabled
+      end
+
+      def filtered_by_error_filter?(error)
+        return unless @ignore_filter
+        !@ignore_filter.call(error)
+      end
+
+      def filtered_error?(error)
+        @ignore[error.class.name] || filtered_by_error_filter?(error)
+      end
+
+      def error_is_ignored?(error)
+        error && filtered_error?(error)
+      end
+
+      def increment_error_count!
+        NewRelic::Agent.get_stats("Errors/all").increment_count
+      end
+
+      def should_exit_notice_error?(exception)
+        if @enabled
+          if !error_is_ignored?(exception)
+            increment_error_count!
+            return exception.nil?
+          end
+        end
+        # disabled or an ignored error, per above
+        true
+      end
+
+      def fetch_from_options(options, key, default=nil)
+        options.delete(key) || default
+      end
+
+      def uri_ref_and_root(options)
+        {
+          :request_uri => fetch_from_options(options, :uri, ''),
+          :request_referer => fetch_from_options(options, :referer, ''),
+          :rails_root => control.root
+        }
+      end
+
+      def custom_params_from_opts(options)
+        # If anything else is left over, treat it like a custom param:
+        fetch_from_options(options, :custom_params, {}).merge(options)
+      end
+
+      def request_params_from_opts(options)
+        value = options.delete(:request_params)
+        if control.capture_params
+          value
+        else
+          nil
+        end
+      end
+
+      def normalized_request_and_custom_params(options)
+        {
+          :request_params => normalize_params(request_params_from_opts(options)),
+          :custom_params  => normalize_params(custom_params_from_opts(options))
+        }
+      end
+
+      def error_params_from_options(options)
+        uri_ref_and_root(options).merge(normalized_request_and_custom_params(options))
+      end
+
+      def sense_method(object, method)
+        object.send(method) if object.respond_to?(method)
+      end
+
+      def extract_source(exception)
+        sense_method(exception, 'source_extract') if @capture_source
+      end
+
+      def extract_stack_trace(exception)
+        actual_exception = sense_method(exception, 'original_exception') || exception
+        sense_method(actual_exception, 'backtrace') || '<no stack trace>'
+      end
+
+      def exception_info(exception)
+        {
+          :file_name => sense_method(exception, 'file_name'),
+          :line_number => sense_method(exception, 'line_number'),
+          :source => extract_source(exception),
+          :stack_trace => extract_stack_trace(exception)
+        }
+      end
+
+      def over_queue_limit?(message)
+        over_limit = (@errors.length >= MAX_ERROR_QUEUE_LENGTH)
+        log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
+        over_limit
+      end
+
+
+      def add_to_error_queue(noticed_error)
+        @lock.synchronize do
+          @errors << noticed_error unless over_queue_limit?(noticed_error.message)
+        end
+      end
+    end
+
+    include NoticeError
+
+    # Notice the error with the given available options:
+    #
+    # * <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
+    #
+    # If anything is left over, it's added to custom params
+    # If exception is nil, the error count is bumped and no traced error is recorded
+    def notice_error(exception, options={})
+      return if should_exit_notice_error?(exception)
+      action_path     = fetch_from_options(options, :metric, (NewRelic::Agent.instance.stats_engine.scope_name || ''))
+      exception_options = error_params_from_options(options).merge(exception_info(exception))
+      add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
+      exception
+    rescue Exception => e
+      log.error("Error capturing an error, yodawg. #{e}")
+    end
+
+    # Get the errors currently queued up.  Unsent errors are left
+    # over from a previous unsuccessful attempt to send them to the server.
+    def harvest_errors(unsent_errors)
+      @lock.synchronize do
+        errors = @errors
+        @errors = []
+
+        if unsent_errors && !unsent_errors.empty?
+          errors = unsent_errors + errors
+        end
+
+        errors
+      end
+    end
+
+    private
+    def log
+      NewRelic::Agent.logger
+    end
+  end
+end
+end