wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/agent/agent_logger.rb

@@ -0,0 +1,165 @@
+require 'logger'
+
+module NewRelic
+  module Agent
+    class AgentLogger
+
+      def initialize(config, root = "", override_logger=nil)
+        create_log(config, root, override_logger)
+        set_log_level!(config)
+        set_log_format!
+
+        gather_startup_logs
+      end
+
+      def fatal(*msgs)
+        @log.fatal(format_messages(msgs))
+      end
+
+      def error(*msgs)
+        @log.error(format_messages(msgs))
+      end
+
+      def warn(*msgs)
+        @log.warn(format_messages(msgs))
+      end
+
+      def info(*msgs)
+        @log.info(format_messages(msgs))
+      end
+
+      def debug(*msgs)
+        @log.debug(format_messages(msgs))
+      end
+
+      # Allows for passing exceptions in explicitly, which format with backtrace
+      def format_messages(msgs)
+        msgs.map do |msg|
+          if msg.respond_to?(:backtrace)
+            "#{msg.class}: #{msg}\n\t#{(msg.backtrace || []).join("\n\t")}"
+          else
+            msg
+          end
+        end.join("\n")
+      end
+
+      def create_log(config, root, override_logger)
+        if !override_logger.nil?
+          @log = override_logger
+        elsif config[:agent_enabled] == false
+          create_null_logger
+        else
+          if wants_stdout(config)
+            @log = ::Logger.new(STDOUT)
+          else
+            create_log_to_file(config, root)
+          end
+        end
+      end
+
+      def create_log_to_file(config, root)
+        path = find_or_create_file_path(config[:log_file_path], root)
+        if path.nil?
+          @log = ::Logger.new(STDOUT)
+          warn("Error creating log directory #{config[:log_file_path]}, using standard out for logging.")
+        else
+          file_path = "#{path}/#{config[:log_file_name]}"
+          begin
+            @log = ::Logger.new(file_path)
+          rescue => e
+            @log = ::Logger.new(STDOUT)
+            warn("Failed creating logger for file #{file_path}, using standard out for logging.", e)
+          end
+        end
+      end
+
+      def create_null_logger
+        null_path = ["/dev/null", "NUL"].detect{|f| File.exists?(f)}
+        @log = ::Logger.new(null_path)
+      end
+
+      def wants_stdout(config)
+        config[:log_file_path].upcase == "STDOUT"
+      end
+
+      def find_or_create_file_path(path_setting, root)
+        for abs_path in [ File.expand_path(path_setting),
+                          File.expand_path(File.join(root, path_setting)) ] do
+          if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
+            return abs_path[%r{^(.*?)/?$}]
+          end
+        end
+        nil
+      end
+
+      def set_log_level!(config)
+        @log.level = AgentLogger.log_level_for(config.fetch(:log_level))
+      end
+
+      LOG_LEVELS = {
+        "debug" => Logger::DEBUG,
+        "info"  => Logger::INFO,
+        "warn"  => Logger::WARN,
+        "error" => Logger::ERROR,
+        "fatal" => Logger::FATAL,
+      }
+
+      def self.log_level_for(level)
+        LOG_LEVELS.fetch(level.to_s.downcase, Logger::INFO)
+      end
+
+      def set_log_format!
+        def @log.format_message(severity, timestamp, progname, msg)
+          prefix = @logdev.dev == STDOUT ? '** [NewRelic]' : ''
+          prefix + "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
+        end
+      end
+
+      def gather_startup_logs
+        StartupLogger.instance.dump(self)
+      end
+    end
+
+    # BBase class for startup logging and testing in multiverse
+    class MemoryLogger
+      def initialize
+        @messages = []
+      end
+
+      attr_accessor :messages, :level
+
+      def fatal(*msgs)
+        messages << [:fatal, msgs]
+      end
+
+      def error(*msgs)
+        messages << [:error, msgs]
+      end
+
+      def warn(*msgs)
+        messages << [:warn, msgs]
+      end
+
+      def info(*msgs)
+        messages << [:info, msgs]
+      end
+
+      def debug(*msgs)
+        messages << [:debug, msgs]
+      end
+
+      def dump(logger)
+        messages.each do |msg|
+          logger.send(msg[0], msg[1])
+        end
+        messages.clear
+      end
+    end
+
+    # In an effort to not lose messages during startup, we trap them in memory
+    # The real logger will then dump its contents out when it arrives.
+    class StartupLogger < MemoryLogger
+      include Singleton
+    end
+  end
+end

data/lib/new_relic/agent/audit_logger.rb

@@ -0,0 +1,72 @@
+require 'logger'
+require 'fileutils'
+
+module NewRelic
+  module Agent
+    class AuditLogger
+      def initialize(config)
+        @config = config
+        @enabled = @config[:'audit_log.enabled']
+        @encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+      end
+
+      attr_writer :enabled
+
+      def enabled?
+        @enabled
+      end
+
+      def setup?
+        !@log.nil?
+      end
+
+      def log_request(uri, data, marshaller)
+        if enabled?
+          setup_logger unless setup?
+          request_body = if marshaller.class.human_readable?
+            marshaller.dump(data, :encoder => @encoder)
+          else
+            marshaller.prepare(data, :encoder => @encoder).inspect
+          end
+          @log.info("REQUEST: #{uri}")
+          @log.info("REQUEST BODY: #{request_body}")
+        end
+      rescue SystemCallError => e
+        ::NewRelic::Agent.logger.warn("Failed writing to audit log: #{e}")
+      end
+
+      def setup_logger
+        path = ensure_log_path
+        @log = ::Logger.new(path || "/dev/null")
+        @log.formatter = log_formatter
+        ::NewRelic::Agent.logger.info("Audit log enabled at '#{path}'") if path
+      end
+
+      def ensure_log_path
+        path = File.expand_path(@config[:'audit_log.path'])
+        log_dir = File.dirname(path)
+
+        begin
+          FileUtils.mkdir_p(log_dir)
+          FileUtils.touch(path)
+        rescue SystemCallError => e
+          msg = "Audit log disabled, failed opening log at '#{path}': #{e}"
+          ::NewRelic::Agent.logger.warn(msg)
+          path = nil
+        end
+
+        path
+      end
+
+      def log_formatter
+        if @formatter.nil?
+          @formatter = Logger::Formatter.new
+          def @formatter.call(severity, time, progname, msg)
+            "[#{time} #{Socket.gethostname} (#{$$})] : #{msg}\n"
+          end
+        end
+        @formatter
+      end
+    end
+  end
+end

data/lib/new_relic/agent/beacon_configuration.rb

@@ -12,81 +12,69 @@ module NewRelic
       # 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
+      def initialize
         @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'
+        ::NewRelic::Agent.logger.debug("Browser timing header: #{@browser_timing_header.inspect}")
+        @browser_timing_static_footer = build_load_file_js
+        ::NewRelic::Agent.logger.debug("Browser timing static footer: #{@browser_timing_static_footer.inspect}")
+        if Agent.config[:'rum.jsonp']
+          ::NewRelic::Agent.logger.debug("Real User Monitoring is using JSONP protocol")
+          @finish_command = 'nrfj'
+        else
+          @finish_command = 'nrf2'
+        end
+
+        if !Agent.config[:'rum.enabled']
+          ::NewRelic::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
+        end
+      end
+
+      def enabled?
+        Agent.config[:'rum.enabled'] && !!Agent.config[:beacon]
       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}
+          Agent.config[: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)
+      def build_load_file_js
         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', '')          
+
+        if Agent.config[:'rum.load_episodes_file'] &&
+          Agent.config[:'rum.load_episodes_file'] != ''
           js << <<-EOS
-var e=document.createElement(\"script\");
-e.type=\"text/javascript\";e.async=true;e.src=\"#{episodes_url}\";
+var e=document.createElement("script");
+e.type="text/javascript";
+e.src=(("http:"===document.location.protocol)?"http:":"https:") + "//" +
+  "#{Agent.config[:episodes_file]}";
 document.body.appendChild(e);
 EOS
         end
-    
+
         js << <<-EOS
 if(NREUMQ.a)NREUMQ.a();
 };
@@ -101,12 +89,12 @@ EOS
       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?
-        
+        return "" if !enabled?
+        return "" if Agent.config[:browser_key].nil?
+
         value = javascript_header
         if value.respond_to?(:html_safe)
           value.html_safe
@@ -117,5 +105,3 @@ EOS
     end
   end
 end
-
-

data/lib/new_relic/agent/browser_monitoring.rb

@@ -5,25 +5,22 @@ module NewRelic
     # 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
@@ -34,10 +31,11 @@ module NewRelic
       # 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
+        if insert_js?
+          NewRelic::Agent.instance.beacon_configuration.browser_timing_header
+        else
+          ""
+        end
       end
 
       # This method returns a string suitable for inclusion in a page
@@ -49,73 +47,140 @@ module NewRelic
       # 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)
+        if insert_js?
+          generate_footer_js(NewRelic::Agent.instance.beacon_configuration)
+        else
+          ""
+        end
       end
 
-      private
+      module_function
 
-      def generate_footer_js(config)
-        if browser_monitoring_start_time
-          application_id = config.application_id
-          beacon = config.beacon
-          license_key = config.browser_monitoring_key
+      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
+        }
 
-          footer_js_string(config, beacon, license_key, application_id)
-        else
-          ''
-        end
+        [obfuscated].pack("m0").gsub("\n", '')
       end
 
       def browser_monitoring_transaction_name
         NewRelic::Agent::TransactionInfo.get.transaction_name
       end
 
+      def browser_monitoring_queue_time
+        clamp_to_positive((current_metric_frame.queue_time.to_f * 1000.0).round)
+      end
+
+      def browser_monitoring_app_time
+        clamp_to_positive(((Time.now - browser_monitoring_start_time).to_f * 1000.0).round)
+      end
+
+      def current_metric_frame
+        Thread.current[:last_metric_frame] || @@dummy_metric_frame
+      end
+
+      def clamp_to_positive(value)
+        return 0.0 if value < 0
+        value
+      end
+
       def browser_monitoring_start_time
         NewRelic::Agent::TransactionInfo.get.start_time
       end
-            
+
+      def self.timings
+        NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(
+          current_metric_frame.queue_time,
+          NewRelic::Agent::TransactionInfo.get)
+      end
+
+      def insert_mobile_response_header(request, response)
+        if mobile_header_found_in?(request) &&
+            NewRelic::Agent.instance.beacon_configuration
+
+          config = NewRelic::Agent.instance.beacon_configuration
+
+          response['X-NewRelic-Beacon-Url'] = beacon_url(request)
+
+          payload = %[ ["#{Agent.config[:application_id]}","#{obfuscate(config, browser_monitoring_transaction_name)}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}] ]
+          response['X-NewRelic-App-Server-Metrics'] = payload
+        end
+      end
+
+      def mobile_header_found_in?(request)
+        headers = ['HTTP_X_NEWRELIC_MOBILE_TRACE', 'X_NEWRELIC_MOBILE_TRACE',
+                   'X-NewRelic-Mobile-Trace']
+        headers.inject(false){|i,m| i || (request.env[m] == 'true')}
+      end
+
+      def beacon_url(request)
+        "#{request.scheme || 'http'}://#{Agent.config[:beacon]}/mobile/1/#{Agent.config[:browser_key]}"
+      end
+
+      private
+
+      # Check whether RUM header and footer should be generated.  Log the
+      # reason if they shouldn't.
+      def insert_js?
+        if NewRelic::Agent.instance.beacon_configuration.nil?
+          ::NewRelic::Agent.logger.debug "Beacon configuration is nil. Skipping browser instrumentation."
+          false
+        elsif ! NewRelic::Agent.instance.beacon_configuration.enabled?
+          ::NewRelic::Agent.logger.debug "Beacon configuration is disabled. Skipping browser instrumentation."
+          ::NewRelic::Agent.logger.debug NewRelic::Agent.instance.beacon_configuration.inspect
+          false
+        elsif Agent.config[:browser_key].nil? || Agent.config[:browser_key].empty?
+          ::NewRelic::Agent.logger.debug "Browser key is not set. Skipping browser instrumentation."
+          false
+        elsif ! NewRelic::Agent.is_transaction_traced?
+          ::NewRelic::Agent.logger.debug "Transaction is not traced. Skipping browser instrumentation."
+          false
+        elsif ! NewRelic::Agent.is_execution_traced?
+          ::NewRelic::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
+          false
+        elsif NewRelic::Agent::TransactionInfo.get.ignore_end_user?
+          ::NewRelic::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
+          false
+        else
+          true
+        end
+      end
+
+      def generate_footer_js(config)
+        if browser_monitoring_start_time
+          footer_js_string(config)
+        else
+          ''
+        end
+      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)
+      def footer_js_string(config)
         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>")
+
+        html_safe_if_needed(%'<script type="text/javascript">#{config.browser_timing_static_footer}NREUMQ.push(["#{config.finish_command}","#{Agent.config[:beacon]}","#{Agent.config[:browser_key]}","#{Agent.config[: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)
@@ -125,18 +190,6 @@ module NewRelic
           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