wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/agent/samplers/delayed_job_lock_sampler.rb

@@ -1,40 +0,0 @@
-require 'new_relic/agent/sampler'
-require 'new_relic/delayed_job_injection'
-
-module NewRelic
-  module Agent
-    module Samplers
-      class DelayedJobLockSampler < NewRelic::Agent::Sampler
-        def initialize
-          super :delayed_job_lock
-          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj']
-          raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
-        end
-
-        def stats
-          stats_engine.get_stats("Custom/DJ Locked Jobs", false)
-        end
-
-        def local_env
-          NewRelic::Control.instance.local_env
-        end
-
-        def worker_name
-          local_env.dispatcher_instance_id
-        end
-
-        def locked_jobs
-          Delayed::Job.count(:conditions => {:locked_by => NewRelic::DelayedJobInjection.worker_name})
-        end
-
-        def self.supported_on_this_platform?
-          defined?(Delayed::Job)
-        end
-
-        def poll
-          stats.record_data_point locked_jobs
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/control/configuration.rb

@@ -1,206 +0,0 @@
-module NewRelic
-  class Control
-    # used to contain methods to look up settings from the
-    # configuration located in newrelic.yml
-    module Configuration
-      def settings
-        unless @settings
-          @settings = (@yaml && merge_defaults(@yaml[env])) || {}
-          # At the time we bind the settings, we also need to run this little piece
-          # of magic which allows someone to augment the id with the app name, necessary
-          if self['multi_homed'] && app_names.size > 0
-            if @local_env.dispatcher_instance_id
-              @local_env.dispatcher_instance_id << ":#{app_names.first}"
-            else
-              @local_env.dispatcher_instance_id = app_names.first
-            end
-          end
-
-        end
-        @settings
-      end
-
-      def merge_defaults(settings_hash)
-        s = {
-          'host' => 'collector.newrelic.com',
-          'ssl' => false,
-          'log_level' => 'info',
-          'apdex_t' => 0.5
-        }
-        s.merge! settings_hash if settings_hash
-        # monitor_daemons replaced with agent_enabled
-        s['agent_enabled'] = s.delete('monitor_daemons') if s['agent_enabled'].nil? && s.include?('monitor_daemons')
-        s
-      end
-
-      # Merge the given options into the config options.
-      # They might be a nested hash
-      def merge_options(options, hash=self)
-        options.each do |key, val|
-          case
-          when key == :config then next
-          when val.is_a?(Hash)
-            merge_options(val, hash[key.to_s] ||= {})
-          when val.nil?
-            hash.delete(key.to_s)
-          else
-            hash[key.to_s] = val
-          end
-        end
-      end
-
-      def merge_server_side_config(data)
-        remove_server_controlled_configs
-        config = Hash.new
-        data.each_pair do |key, value|
-          if key.include?('.')
-            key = key.split('.')
-            config[key.first] ||= Hash.new
-            config[key.first][key[1]] = value
-          else
-            config[key] = value
-          end
-        end
-        merge_options(config)
-      end
-
-      def remove_server_controlled_configs
-        settings.delete('transaction_tracer')
-        settings.delete('slow_sql')
-        settings.delete('error_collector')
-        settings.delete('capture_params')
-      end
-
-      def [](key)
-        fetch(key)
-      end
-
-      def []=(key, value)
-        settings[key] = value
-      end
-
-      def fetch(key, default=nil)
-        settings.fetch(key, default)
-      end
-
-      def apdex_t
-        # Always initialized with a default
-        @apdex_t_float ||= fetch('apdex_t').to_f
-      end
-
-      def license_key
-        env_setting = ENV['NEW_RELIC_LICENSE_KEY'] || ENV['NEWRELIC_LICENSE_KEY']
-        fetch('license_key', env_setting)
-      end
-      
-      def capture_params
-        fetch('capture_params')
-      end
-      
-      # True if we are sending data to the server, monitoring production
-      def monitor_mode?
-        fetch('monitor_mode', fetch('enabled'))
-      end
-
-      # True if we are capturing data and displaying in /newrelic
-      def developer_mode?
-        fetch('developer_mode', fetch('developer'))
-      end
-      
-      # whether we should install the
-      # NewRelic::Rack::BrowserMonitoring middleware automatically on
-      # Rails applications
-      def browser_monitoring_auto_instrument?
-        fetch('browser_monitoring', {}).fetch('auto_instrument', true)
-      end
-
-      def multi_threaded?
-        fetch('multi_threaded')
-      end
-
-      def disable_serialization?
-        fetch('disable_serialization', !DependencyDetection.installed?(:resque))
-      end
-      def disable_serialization=(b)
-        self['disable_serialization'] = b
-      end
-      
-      # True if we should view files in textmate
-      def use_textmate?
-        fetch('textmate')
-      end
-      
-      # defaults to 2MiB
-      def post_size_limit
-        fetch('post_size_limit', 2 * 1024 * 1024)
-      end
-
-      # Configuration option of the same name to indicate that we should connect
-      # to New Relic synchronously on startup.  This means when the agent is loaded it
-      # won't return without trying to set up the server connection at least once
-      # which can make startup take longer.  Defaults to false.
-      def sync_startup
-        fetch('sync_startup', false)
-      end
-
-      # Configuration option of the same name to indicate that we should flush
-      # data to the server on exiting.  Defaults to true.
-      def send_data_on_exit
-        fetch('send_data_on_exit', true)
-      end
-
-      def dispatcher_instance_id
-        self['dispatcher_instance_id'] || @local_env.dispatcher_instance_id
-      end
-
-      def dispatcher
-        (self['dispatcher'] && self['dispatcher'].to_sym) || @local_env.dispatcher
-      end
-      def app_names
-        case self['app_name']
-        when Array then self['app_name']
-        when String then self['app_name'].split(';')
-        else [ env ]
-        end
-      end
-      def validate_seed
-        self['validate_seed'] || ENV['NR_VALIDATE_SEED']
-      end
-      def validate_token
-        self['validate_token'] || ENV['NR_VALIDATE_TOKEN']
-      end
-      
-      def use_ssl?
-        @use_ssl = fetch('ssl', false) unless @use_ssl
-        @use_ssl
-      end
-      
-      def log_file_path
-        fetch('log_file_path', 'log/')
-      end
-      
-      # only verify certificates if you're very sure you want this
-      # level of security, it includes possibly app-crashing dns
-      # lookups every connection to the server
-      def verify_certificate?
-        unless @verify_certificate
-          unless use_ssl?
-            @verify_certificate = false
-          else
-            @verify_certificate = fetch('verify_certificate', false)
-          end
-        end
-        @verify_certificate
-      end
-
-      def disable_backtrace_cleanup?
-        fetch('disable_backtrace_cleanup')
-      end
-
-      def has_slow_sql_config?
-        self['slow_sql'] && self['slow_sql'].has_key?('enabled')
-      end
-    end
-    include Configuration
-  end
-end

data/lib/new_relic/control/logging_methods.rb

@@ -1,143 +0,0 @@
-
-module NewRelic
-  class Control
-    # Contains methods that relate to locating, creating, and writing
-    # to the log file and/or standard out
-    module LoggingMethods
-
-      attr_accessor :log_file
-      
-      # returns either the log set up with setup_log or else a new
-      # logger pointing to standard out, if we're trying to log before
-      # a log exists
-      def log
-        if !@log
-          l = Logger.new(STDOUT)
-          l.level = Logger::INFO          
-          return l
-        end
-        @log
-      end
-
-      # send the given message to STDOUT so that it shows
-      # up in the console.  This should be used for important informational messages at boot.
-      # The to_stdout may be implemented differently by different config subclasses.
-      # This will NOT print anything if tracers are not enabled
-      def log!(msg, level=:info)
-        to_stdout msg
-        return unless should_log?
-        log.send level, msg if @log
-      end
-      
-      # true if the agent has settings, and the agent is enabled,
-      # otherwise false
-      def should_log?
-        @settings && agent_enabled?
-      end
-
-      # set the log level as specified in the config file
-      #
-      # Possible values are from the Logger class: debug, info, warn,
-      #error, and fatal
-      # Defaults to info
-      def set_log_level!(logger)
-        case fetch("log_level","info").downcase
-          when "debug" then logger.level = Logger::DEBUG
-          when "info" then logger.level = Logger::INFO
-          when "warn" then logger.level = Logger::WARN
-          when "error" then logger.level = Logger::ERROR
-          when "fatal" then logger.level = Logger::FATAL
-          else logger.level = Logger::INFO
-        end
-        logger
-      end
-
-      # patches the logger's format_message method to change the format just for our logger
-      def set_log_format!(logger)
-        def logger.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
-        logger
-      end
-
-      # Create the logger using the configuration variables
-      #
-      # Control subclasses may override this, but it can be called multiple times.
-      def setup_log
-        if log_to_stdout?
-          @log = Logger.new(STDOUT) 
-        else
-          @log_file = "#{log_path}/#{log_file_name}"
-          @log = Logger.new(@log_file) rescue nil
-          @log ||= Logger.new(STDOUT) # failsafe to STDOUT
-        end
-        
-        if @log
-          set_log_format!(@log)
-          set_log_level!(@log)
-        end
-        # note this is not the variable from above - it is the `log`
-        # method, which returns a default logger if none is setup
-        # above
-        log
-      end
-      
-      # simply puts a message to standard out, prepended with the
-      # '** [NewRelic]' sigil to make sure people know where the message
-      # comes from. This should be used sparingly
-      def to_stdout(msg)
-        STDOUT.puts "** [NewRelic] " + msg
-      end
-      
-      # Sets up and caches the log path, attempting to create it if it
-      # does not exist.  If it does not succeed, it prints an
-      # error and returns nil.
-      # This comes from the configuration variable 'log_file_path' in the configuration file.
-      def log_path
-        return @log_path if @log_path
-        if log_to_stdout?
-          @log_path = nil
-        else
-          if ENV['NEW_RELIC_LOG']
-            log_path_setting = File.dirname(ENV['NEW_RELIC_LOG'])
-          else
-            log_path_setting = fetch('log_file_path', 'log')
-          end
-          @log_path = find_or_create_file_path(log_path_setting)
-          log!("Error creating log directory #{log_path_setting}, using standard out for logging.", :warn) unless @log_path
-        end
-        @log_path
-      end
-        
-      def find_or_create_file_path(path_setting)
-        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 log_to_stdout?
-        return true if @stdout
-        destination = ENV['NEW_RELIC_LOG'] || fetch('log_file_path', 'log')
-        if destination.upcase == 'STDOUT'
-          @stdout = true
-        end
-      end
-        
-      # Retrieves the log file's name from the config file option
-      #'log_file_name', defaulting to 'newrelic_agent.log'
-      def log_file_name
-        if ENV['NEW_RELIC_LOG']
-          File.basename(ENV['NEW_RELIC_LOG'])
-        else
-          fetch('log_file_name', 'newrelic_agent.log')
-        end
-      end
-    end
-    include LoggingMethods
-  end
-end

data/lib/new_relic/data_serialization.rb

@@ -1,151 +0,0 @@
-require 'fileutils'
-require 'new_relic/language_support'
-
-module NewRelic
-  # Handles serialization of data to disk, to save on contacting the
-  # server. Lowers both server and client overhead, if the disk is not overloaded
-  class DataSerialization
-    include NewRelic::LanguageSupport::DataSerialization
-    
-    module ClassMethods
-      # Check whether the store is too large, too old, or the
-      # pid file is too old. If so, we should send the data
-      # right away. If not, we presumably store it for later sending
-      # (handled elsewhere)
-      def should_send_data?
-        NewRelic::Control.instance.disable_serialization? || store_too_large? ||
-          store_too_old? || pid_too_old? ||
-          NewRelic::LanguageSupport.using_version?('1.8.6')
-      rescue => e
-        NewRelic::Control.instance.disable_serialization = true
-        NewRelic::Control.instance.log.warn("Disabling serialization: #{e.message}")
-        true
-      end
-
-      # A combined locked read/write from the store file - reduces
-      # contention by not acquiring the lock and file handle twice
-      def read_and_write_to_file
-        with_locked_store do |f|
-          result = (yield get_data_from_file(f))
-          f.rewind
-          f.truncate(0)
-          write_contents_nonblockingly(f, dump(result)) if result
-        end
-      rescue Errno::ENOENT => e
-        NewRelic::Control.instance.log.warn(e.message)
-      end
-      
-      # touches the age file that determines whether we should send
-      # data now or not
-      def update_last_sent!
-        FileUtils.touch(pid_file_path)
-      end
-      
-      def pid_too_old?
-        return true unless File.exists?(pid_file_path)
-        age = (Time.now.to_i - File.mtime(pid_file_path).to_i)
-        NewRelic::Control.instance.log.debug("Pid was #{age} seconds old, sending data") if age > 60
-        age > 60
-      end
-      
-      def store_too_old?
-        return true unless File.exists?(file_path)
-        age = (Time.now.to_i - File.mtime(file_path).to_i)
-        NewRelic::Control.instance.log.debug("Store was #{age} seconds old, sending data") if age > 60
-        age > 50
-      end      
-    
-      def store_too_large?
-        return true unless File.exists?(file_path)
-        size = File.size(file_path) > max_size
-        NewRelic::Control.instance.log.debug("Store was oversize, sending data") if size
-        size
-      end
-      
-      private
-      
-      def open_arguments
-        if defined?(Encoding)
-          [file_path, File::RDWR | File::CREAT, {:internal_encoding => nil}]
-        else
-          [file_path, File::RDWR | File::CREAT]
-        end
-      end
-      
-      def with_locked_store
-        File.open(*open_arguments) do |f|
-          f.flock(File::LOCK_EX)
-          begin
-            yield(f)
-          ensure
-            f.flock(File::LOCK_UN)
-          end
-        end
-      rescue => e
-        NewRelic::Control.instance.log.error("Error serializing data to disk: #{e.inspect}")
-        NewRelic::Control.instance.log.debug(e.backtrace.split("\n"))
-        # re-raise so that serialization will be disabled higher up the stack
-        raise e
-      end
-
-      def get_data_from_file(f)
-        data = read_until_eof_error(f)
-        result = load(data)
-        f.truncate(0)
-        result
-      end
-
-      def write_contents_nonblockingly(f, string)
-        result = 0
-        while (result < string.length)
-          result += f.write_nonblock(string)
-        end
-      rescue Errno::EAGAIN, Errno::EINTR
-        IO.select(nil, [f])
-        retry
-      end
-
-      def read_until_eof_error(f)
-        accumulator = ""
-        while(true)
-          accumulator << f.read_nonblock(10_000)
-        end
-      rescue Errno::EAGAIN, Errno::EINTR
-        IO.select([f])
-        retry
-      rescue EOFError
-        accumulator
-      end
-      
-      def max_size
-        10_000
-      end
-
-      def dump(object)
-        Marshal.dump(object.clone)
-      end
-      
-      def load(dump)
-        if dump.respond_to?(:size) && dump.size == 0
-          NewRelic::Control.instance.log.debug("Spool file empty.")
-          return nil
-        end
-        Marshal.load(dump)
-      rescue ArgumentError, TypeError => e
-        NewRelic::Control.instance.log.error("Error loading data from newrelic_agent_store.db: #{e.inspect}")
-        NewRelic::Control.instance.log.debug(e.backtrace.inspect)
-        nil
-      end
-            
-      def file_path
-        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.db"
-      end
-
-      def pid_file_path
-        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.pid"
-      end
-    end
-    extend ClassMethods
-  end
-end
-