newrelic_rpm 3.5.4.35.beta → 3.5.5.38

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

@@ -25,18 +25,18 @@ module NewRelic
       # of configuration values from the server
       def initialize
         @browser_timing_header = build_browser_timing_header
-        NewRelic::Control.instance.log.debug("Browser timing header: #{@browser_timing_header.inspect}")
+        ::NewRelic::Agent.logger.debug("Browser timing header: #{@browser_timing_header.inspect}")
         @browser_timing_static_footer = build_load_file_js
-        NewRelic::Control.instance.log.debug("Browser timing static footer: #{@browser_timing_static_footer.inspect}")
+        ::NewRelic::Agent.logger.debug("Browser timing static footer: #{@browser_timing_static_footer.inspect}")
         if Agent.config[:'rum.jsonp']
-          NewRelic::Control.instance.log.debug("Real User Monitoring is using JSONP protocol")
+          ::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::Control.instance.log.warn("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
+          ::NewRelic::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
         end
       end
 

data/lib/new_relic/agent/browser_monitoring.rb

@@ -93,6 +93,12 @@ module NewRelic
         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
@@ -122,23 +128,23 @@ module NewRelic
       # 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."
+          ::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
+          ::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."
+          ::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."
+          ::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."
+          ::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."
+          ::NewRelic::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
           false
         else
           true

data/lib/new_relic/agent/busy_calculator.rb

@@ -37,7 +37,7 @@ module NewRelic
         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")}")
+            ::NewRelic::Agent.logger.warn("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
           else
             @accumulator += (end_time - @entrypoint_stack.pop).to_f
           end
@@ -85,7 +85,7 @@ module NewRelic
 
         busy = busy / time_window
 
-        instance_busy_stats.record_data_point busy
+        instance_busy_stats.record_data_point busy if Agent.config[:report_instance_busy]
         @harvest_start = t0
       end
 

data/lib/new_relic/agent/configuration.rb

@@ -1,5 +1,26 @@
 require 'new_relic/agent/configuration/manager'
 
+# The agent's configuration is accessed through a configuration object exposed
+# by ::NewRelic::Agent.config.  It provides a hash like interface to the
+# agent's settings.
+#
+# For example:
+# ::NewRelic::Agent.config[:'transaction_tracer.enabled']
+# determines whether transaction tracing is enabled.  String and symbol keys
+# are treated indifferently and nested keys are collapsed and concatenated with
+# a dot (i.e. {:a => {:b => 'c'} becomes { 'a.b' => 'c'}).
+#
+# The agent reads configuration from a variety of sources. These sources are
+# modeled as a set of layers.  The top layer has the highest priority.  If the
+# top layer does not contain the requested setting the config object will search
+# through the subsequent layers returning the first value it finds.
+#
+# Configuration layers include EnvironmentSource (which reads settings from
+# ENV), ServerSource (which reads Server Side Config from New Relic's servers),
+# YamlSource (which reads from newrelic.yml),  ManualSource (which reads
+# arguments passed to NewRelic::Agent.manual_start or potentially other
+# methods), and Defaults (which contains default settings).
+#
 module NewRelic
   module Agent
     module Configuration
@@ -28,6 +49,10 @@ module NewRelic
           "#<#{self.class.name}:#{object_id} #{super}>"
         end
 
+        def to_hash
+          {}.replace(self)
+        end
+
         protected
         # turns {'a' => {'b' => 'c'}} into {'a.b' => 'c'}
         def dot_flattened(nested_hash, names=[], result={})

data/lib/new_relic/agent/configuration/defaults.rb

@@ -2,17 +2,47 @@ module NewRelic
   module Agent
     module Configuration
       DEFAULTS = {
-        :config_path => File.join('config', 'newrelic.yml'),
-
+        :config_path => Proc.new {
+          # Check a sequence of file locations for newrelic.yml
+          files = []
+          files << File.join("config","newrelic.yml")
+          files << File.join("newrelic.yml")
+          if ENV["HOME"]
+            files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
+            files << File.join(ENV["HOME"], "newrelic.yml")
+          end
+          files.detect do |file|
+            File.expand_path(file) if File.exists? file
+          end
+        },
         :app_name   => Proc.new { NewRelic::Control.instance.env },
-        :dispatcher => Proc.new { NewRelic::Control.instance.local_env.dispatcher },
-
+        :dispatcher => Proc.new { NewRelic::Control.instance.local_env.discovered_dispatcher },
+        :framework => Proc.new do
+          case
+          when defined?(::NewRelic::TEST) then :test
+          when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
+          when defined?(::Rails)
+            case Rails::VERSION::MAJOR
+            when 0..2
+              :rails
+            when 3
+              :rails3
+            when 4
+              :rails4
+            else
+              Agent.logger.error "Detected unsupported Rails version #{Rails::VERSION::STRING}"
+            end
+          when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+          when defined?(::NewRelic::IA) then :external
+          else :ruby
+          end
+        end,
         :enabled         => true,
         :monitor_mode    => Proc.new { self[:enabled] },
         :agent_enabled   => Proc.new do
           self[:enabled] &&
           (self[:developer_mode] || self[:monitor_mode] || self[:monitor_daemons]) &&
-          !!NewRelic::Control.instance.local_env.dispatcher
+          !!NewRelic::Agent.config[:dispatcher]
         end,
         :developer_mode  => Proc.new { self[:developer] },
         :developer       => false,
@@ -36,11 +66,17 @@ module NewRelic
         :start_channel_listener => false,
         :data_report_period     => 60,
         :keep_retrying          => true,
+        :report_instance_busy   => true,
 
         :log_file_name => 'newrelic_agent.log',
         :log_file_path => 'log/',
         :log_level     => 'info',
 
+        :'audit_log.enabled'      => false,
+        :'audit_log.path'         => Proc.new {
+          File.join(self[:log_file_path], 'newrelic_audit.log')
+        },
+
         :disable_samplers                     => false,
         :disable_resque                       => false,
         :disable_dj                           => false,
@@ -79,10 +115,11 @@ module NewRelic
         :'rum.load_episodes_file' => true,
         :'browser_monitoring.auto_instrument' => Proc.new { self[:'rum.enabled'] },
 
-        :'thread_profiler.is_supported' => Proc.new { NewRelic::Agent::ThreadProfiler.is_supported? },
-        :'thread_profiler.enabled'      => Proc.new { self[:'thread_profiler.is_supported'] },
+        :'cross_process.enabled'  => true,
+
+        :'thread_profiler.enabled' => Proc.new { NewRelic::Agent::ThreadProfiler.is_supported? },
 
-        :marshaller => Proc.new { NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? :json : :pruby }
+        :marshaller => Proc.new { NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? 'json' : 'pruby' }
       }.freeze
     end
   end