sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/agent/agent_logger.rb

@@ -0,0 +1,173 @@
+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
+
+      def is_startup_logger?
+        false
+      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
+
+    # Base class for startup logging and testing in multiverse
+    class MemoryLogger
+      def initialize
+        @messages = []
+      end
+
+      def is_startup_logger?
+        true
+      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

@@ -0,0 +1,107 @@
+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
+
+      # 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
+        @browser_timing_header = build_browser_timing_header
+        ::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 = []
+          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
+        js = <<-EOS
+if (!NREUMQ.f) { NREUMQ.f=function() {
+NREUMQ.push(["load",new Date().getTime()]);
+EOS
+
+        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.src=(("http:"===document.location.protocol)?"http:":"https:") + "//" +
+  "#{Agent.config[:episodes_file]}";
+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 !enabled?
+        return "" if Agent.config[:browser_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,195 @@
+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
+        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
+      # - 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
+        if insert_js?
+          generate_footer_js(NewRelic::Agent.instance.beacon_configuration)
+        else
+          ""
+        end
+      end
+
+      module_function
+
+      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
+
+      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 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 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}","#{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)
+        if string.respond_to?(:html_safe)
+          string.html_safe
+        else
+          string
+        end
+      end
+    end
+  end
+end