wd_newrelic_rpm 3.3.4.1

data/lib/new_relic/agent/beacon_configuration.rb

@@ -0,0 +1,121 @@
+module NewRelic
+  module Agent
+    # This class contains the configuration data for setting up RUM
+    # headers and footers - acts as a cache of this data so we don't
+    # need to look it up or reconfigure it every request
+    class BeaconConfiguration
+
+      # the statically generated header - generated when the beacon
+      # configuration is created - does not vary per page
+      attr_reader :browser_timing_header
+
+      # the static portion of the RUM footer - this part does not vary
+      # by which request is in progress
+      attr_reader :browser_timing_static_footer
+      
+      # the application id we include in the javascript -
+      # crossreferences with the application id on the collectors
+      attr_reader :application_id
+
+      # the key used for browser monitoring. This is different from
+      # the account key
+      attr_reader :browser_monitoring_key
+
+      # which beacon we should report to - set by startup of the agent
+      attr_reader :beacon
+
+      # whether RUM is enabled or not - determined based on server and
+      # local config
+      attr_reader :rum_enabled
+      
+      # whether JSONP is used to communicate with the Beacon or not
+      attr_reader :rum_jsonp
+      
+      # RUM footer command used for 'finish' - based on whether JSONP is
+      # being used. 'nrfj' for JSONP, otherwise 'nrf2'
+      attr_reader :finish_command
+      
+      # A static javascript header that is identical for every account
+      # and application
+      JS_HEADER = "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
+      
+      # Creates a new browser configuration data. Argument is a hash
+      # of configuration values from the server
+      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}")
+        @rum_jsonp = connect_data['rum.jsonp']
+        @rum_jsonp = true if @rum_jsonp.nil?
+        NewRelic::Control.instance.log.debug("Real User Monitoring is using JSONP protocol") if @rum_jsonp
+        @finish_command = @rum_jsonp ?  'nrfj' : 'nrf2'
+      end
+      
+      # returns a memoized version of the bytes in the license key for
+      # obscuring transaction names in the javascript
+      def license_bytes
+        if @license_bytes.nil?
+          @license_bytes = []
+          NewRelic::Control.instance.license_key.each_byte {|byte| @license_bytes << byte}
+        end
+        @license_bytes
+      end
+      
+      # returns a snippet of text that does not change
+      # per-transaction. Is empty when rum is disabled, or we are not
+      # including the episodes file dynamically (i.e. the user
+      # includes it themselves)
+      def build_load_file_js(connect_data)
+        js = <<-EOS
+if (!NREUMQ.f) { NREUMQ.f=function() {
+NREUMQ.push(["load",new Date().getTime()]);
+EOS
+    
+        if connect_data.fetch('rum.load_episodes_file', true)
+          episodes_url = connect_data.fetch('episodes_url', '')          
+          js << <<-EOS
+var e=document.createElement(\"script\");
+e.type=\"text/javascript\";e.async=true;e.src=\"#{episodes_url}\";
+document.body.appendChild(e);
+EOS
+        end
+    
+        js << <<-EOS
+if(NREUMQ.a)NREUMQ.a();
+};
+NREUMQ.a=window.onload;window.onload=NREUMQ.f;
+};
+EOS
+        js
+      end
+
+      # returns a copy of the static javascript header, in case people
+      # are munging strings somewhere down the line
+      def javascript_header
+        JS_HEADER.dup
+      end
+      
+      # Returns the header string, properly html-safed if needed
+      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,142 @@
+require 'base64'
+require 'new_relic/agent/beacon_configuration'
+module NewRelic
+  module Agent
+    # This module contains support for Real User Monitoring - the
+    # javascript generation and configuration
+    module BrowserMonitoring
+      
+     
+      class DummyMetricFrame
+        def initialize
+          @attributes = {}
+        end
+        
+        def user_attributes
+          @attributes
+        end
+        
+        def queue_time
+          0.0
+        end
+      end
+            
+      @@dummy_metric_frame = DummyMetricFrame.new
+      
+      
+      # This method returns a string suitable for inclusion in a page
+      # - known as 'manual instrumentation' for Real User
+      # Monitoring. Can return either a script tag with associated
+      # javascript, or in the case of disabled Real User Monitoring,
+      # an empty string
+      #
+      # This is the header string - it should be placed as high in the
+      # page as is reasonably possible - that is, before any style or
+      # javascript inclusions, but after any header-related meta tags
+      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
+
+      # This method returns a string suitable for inclusion in a page
+      # - known as 'manual instrumentation' for Real User
+      # Monitoring. Can return either a script tag with associated
+      # javascript, or in the case of disabled Real User Monitoring,
+      # an empty string
+      #
+      # This is the footer string - it should be placed as low in the
+      # page as is reasonably possible.
+      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(config)
+      end
+
+      private
+
+      def generate_footer_js(config)
+        if browser_monitoring_start_time
+          application_id = config.application_id
+          beacon = config.beacon
+          license_key = config.browser_monitoring_key
+
+          footer_js_string(config, beacon, license_key, application_id)
+        else
+          ''
+        end
+      end
+
+      def browser_monitoring_transaction_name
+        NewRelic::Agent::TransactionInfo.get.transaction_name
+      end
+
+      def browser_monitoring_start_time
+        NewRelic::Agent::TransactionInfo.get.start_time
+      end
+            
+      def metric_frame_attribute(key)
+        current_metric_frame.user_attributes[key] || ""
+      end
+      
+      def current_metric_frame
+        Thread.current[:last_metric_frame] || @@dummy_metric_frame      
+      end
+      
+      def tt_guid
+        txn = NewRelic::Agent::TransactionInfo.get
+        return txn.guid if txn.include_guid?
+        ""
+      end
+      
+      def tt_token
+        return NewRelic::Agent::TransactionInfo.get.token
+      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((current_metric_frame.queue_time.to_f * 1000.0).round)
+      end
+
+      def footer_js_string(config, beacon, license_key, application_id)
+        obfuscated_transaction_name = obfuscate(config, browser_monitoring_transaction_name)
+        
+        user = obfuscate(config, metric_frame_attribute(:user))
+        account = obfuscate(config, metric_frame_attribute(:account))
+        product = obfuscate(config, metric_frame_attribute(:product))
+        
+        html_safe_if_needed("<script type=\"text/javascript\">#{config.browser_timing_static_footer}NREUMQ.push([\"#{config.finish_command}\",\"#{beacon}\",\"#{license_key}\",#{application_id},\"#{obfuscated_transaction_name}\",#{browser_monitoring_queue_time},#{browser_monitoring_app_time},new Date().getTime(),\"#{tt_guid}\",\"#{tt_token}\",\"#{user}\",\"#{account}\",\"#{product}\"])</script>")
+      end
+
+      def html_safe_if_needed(string)
+        if string.respond_to?(:html_safe)
+          string.html_safe
+        else
+          string
+        end
+      end
+
+      def obfuscate(config, text)
+        obfuscated = ""
+        key_bytes = config.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,99 @@
+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
+      
+      # sets up busy calculations based on the start and end of
+      # transactions - used for a rough estimate of what percentage of
+      # wall clock time is spent processing requests
+      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
+      
+      # called when a transaction finishes, to add time to the
+      # instance variable accumulator. this is harvested when we send
+      # data to the server
+      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
+      
+      # this returns the size of the entry point stack, which
+      # determines how many transactions are running
+      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 class is used by NewRelic::Agent.set_sql_obfuscator to chain multiple
+# obfuscation blocks when not using the default :replace action
+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/database.rb

@@ -0,0 +1,223 @@
+require 'singleton'
+
+module NewRelic
+  # columns for a mysql explain plan
+  MYSQL_EXPLAIN_COLUMNS = [
+                           "Id",
+                           "Select Type",
+                           "Table",
+                           "Type",
+                           "Possible Keys",
+                           "Key",
+                           "Key Length",
+                           "Ref",
+                           "Rows",
+                           "Extra"
+                          ].freeze
+  
+  module Agent
+    module Database
+      extend self
+      
+      def obfuscate_sql(sql)
+        Obfuscator.instance.obfuscator.call(sql)
+      end
+      
+      def set_sql_obfuscator(type, &block)
+        Obfuscator.instance.set_sql_obfuscator(type, &block)
+      end
+      
+      def get_connection(config)
+        ConnectionManager.instance.get_connection(config)
+      end
+      
+      def close_connections
+        ConnectionManager.instance.close_connections
+      end
+      
+      # Perform this in the runtime environment of a managed
+      # application, to explain the sql statement executed within a
+      # segment of a transaction sample. Returns an array of
+      # explanations (which is an array rows consisting of an array of
+      # strings for each column returned by the the explain query)
+      # Note this happens only for statements whose execution time
+      # exceeds a threshold (e.g. 500ms) and only within the slowest
+      # transaction in a report period, selected for shipment to New
+      # Relic
+      def explain_sql(sql, connection_config)
+        return nil unless sql && connection_config
+        statement = sql.split(";\n")[0] # only explain the first
+        explain_sql = explain_statement(statement, connection_config)
+        return explain_sql || []
+      end
+      
+      def explain_statement(statement, config)
+        if is_select?(statement)
+          handle_exception_in_explain do
+            connection = get_connection(config)
+            plan = nil
+            if connection
+              plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
+            end
+            return plan
+          end
+        end
+      end
+      
+      def process_resultset(items)
+        # The resultset type varies for different drivers.  Only thing you can count on is
+        # that it implements each.  Also: can't use select_rows because the native postgres
+        # driver doesn't know that method.
+        
+        headers = []
+        values = []
+        if items.respond_to?(:each_hash)
+          items.each_hash do |row|
+            headers = row.keys
+            values << headers.map{|h| row[h] }
+          end
+        elsif items.respond_to?(:each)
+          items.each do |row|
+            if row.kind_of?(Hash)
+              headers = row.keys
+              values << headers.map{|h| row[h] }
+            else
+              values << row
+            end
+          end
+        else
+          values = [items]
+        end
+        
+        headers = nil if headers.empty?
+        [headers, values]
+      end
+
+      def handle_exception_in_explain
+        yield
+      rescue => e
+        begin
+          # guarantees no throw from explain_sql
+          NewRelic::Control.instance.log.error("Error getting query plan: #{e.message}")
+          NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
+        rescue
+          # double exception. throw up your hands
+        end
+      end
+      
+      def is_select?(statement)
+        # split the string into at most two segments on the
+        # system-defined field separator character
+        first_word, rest_of_statement = statement.split($;, 2)
+        (first_word.upcase == 'SELECT')
+      end
+      
+      class ConnectionManager
+        include Singleton
+
+        # Returns a cached connection for a given ActiveRecord
+        # configuration - these are stored or reopened as needed, and if
+        # we cannot get one, we ignore it and move on without explaining
+        # the sql
+        def get_connection(config)
+          @connections ||= {}
+          
+          connection = @connections[config]
+          
+          return connection if connection
+          
+          begin
+            connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
+            @connections[config] = connection
+          rescue => e
+            NewRelic::Agent.agent.log.error("Caught exception #{e} trying to get connection to DB for explain. Control: #{config}")
+            NewRelic::Agent.agent.log.error(e.backtrace.join("\n"))
+            nil
+          end
+        end
+        
+        # Closes all the connections in the internal connection cache
+        def close_connections
+          @connections ||= {}
+          @connections.values.each do |connection|
+            begin
+              connection.disconnect!
+            rescue
+            end
+          end
+          
+          @connections = {}
+        end
+      end
+
+      class Obfuscator
+        include Singleton
+        
+        attr_reader :obfuscator
+        
+        def initialize
+          reset
+        end
+
+        def reset
+          @obfuscator = method(:default_sql_obfuscator)
+        end
+        
+        # Sets the sql obfuscator used to clean up sql when sending it
+        # to the server. Possible types are:
+        #
+        # :before => sets the block to run before the existing
+        # obfuscators
+        #
+        # :after => sets the block to run after the existing
+        # obfuscator(s)
+        #
+        # :replace => removes the current obfuscator and replaces it
+        # with the provided block
+        def set_sql_obfuscator(type, &block)
+          if type == :before
+            @obfuscator = NewRelic::ChainedCall.new(block, @obfuscator)
+          elsif type == :after
+            @obfuscator = NewRelic::ChainedCall.new(@obfuscator, block)
+          elsif type == :replace
+            @obfuscator = block
+          else
+            fail "unknown sql_obfuscator type #{type}"
+          end
+        end
+        
+        def default_sql_obfuscator(sql)
+          stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
+          adapter = stmt.adapter
+          obfuscated = remove_escaped_quotes(stmt)
+          obfuscated = obfuscate_single_quote_literals(obfuscated)
+          if !(adapter.to_s =~ /postgres/ || adapter.to_s =~ /sqlite/)
+            obfuscated = obfuscate_double_quote_literals(obfuscated)
+          end
+          obfuscated = obfuscate_numeric_literals(obfuscated)
+          obfuscated.to_s # return back to a regular String
+        end
+
+        def remove_escaped_quotes(sql)
+          sql.gsub(/\\"/, '').gsub(/\\'/, '')
+        end
+
+        def obfuscate_single_quote_literals(sql)
+          sql.gsub(/'(?:[^']|'')*'/, '?')
+        end
+
+        def obfuscate_double_quote_literals(sql)
+          sql.gsub(/"(?:[^"]|"")*"/, '?')
+        end
+
+        def obfuscate_numeric_literals(sql)
+          sql.gsub(/\b\d+\b/, "?")
+        end
+      end
+
+      class Statement < String        
+        attr_accessor :adapter
+      end
+    end
+  end
+end