ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/lib/new_relic/agent/beacon_configuration.rb

@@ -1,16 +1,46 @@
 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
-      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>"
+      # 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']
@@ -22,8 +52,14 @@ module NewRelic
         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 = []
@@ -31,18 +67,42 @@ module NewRelic
         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)
-        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);})();"
+        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?

data/lib/new_relic/agent/browser_monitoring.rb

@@ -2,8 +2,37 @@ 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?
@@ -11,36 +40,61 @@ module NewRelic
         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
+        generate_footer_js(config)
       end
 
       private
 
-      def generate_footer_js
+      def generate_footer_js(config)
         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)
+          footer_js_string(config, beacon, license_key, application_id)
         else
           ''
         end
       end
 
       def browser_monitoring_transaction_name
-        Thread.current[:newrelic_most_recent_transaction] || "<unknown>"
+        NewRelic::Agent::TransactionInfo.get.transaction_name
       end
 
       def browser_monitoring_start_time
-        Thread.current[:newrelic_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
@@ -51,12 +105,17 @@ module NewRelic
       end
 
       def browser_monitoring_queue_time
-        clamp_to_positive((Thread.current[:newrelic_queue_time].to_f * 1000.0).round)
+        clamp_to_positive((current_metric_frame.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>")
+      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)
@@ -67,9 +126,9 @@ module NewRelic
         end
       end
 
-      def obfuscate(text)
+      def obfuscate(config, text)
         obfuscated = ""
-        key_bytes = NewRelic::Agent.instance.beacon_configuration.license_bytes
+        key_bytes = config.license_bytes
         index = 0
         text.each_byte{|byte|
           obfuscated.concat((byte ^ key_bytes[index % 13].to_i))

data/lib/new_relic/agent/busy_calculator.rb

@@ -14,7 +14,10 @@ module NewRelic
 
       # 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
@@ -23,7 +26,10 @@ module NewRelic
           @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
@@ -36,7 +42,9 @@ module NewRelic
           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

data/lib/new_relic/agent/chained_call.rb

@@ -1,5 +1,5 @@
-# This is used to allow obfuscators to be chained.
-
+# 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

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