ghazel-newrelic_rpm 3.1.0.1

data/lib/new_relic/data_serialization.rb

@@ -0,0 +1,84 @@
+require 'fileutils'
+module NewRelic
+  class DataSerialization
+    module ClassMethods
+      def should_send_data?
+        NewRelic::Control.instance.disable_serialization? || (File.size(file_path) >= max_size)
+      rescue Exception => e
+        # This is not what we really should do here, but the fail-safe
+        # behavior is to do what the older agent did: send data every
+        # time we think we might want to send data.
+        true
+      end
+      
+      def read_and_write_to_file
+        with_locked_store do |f|
+          result = (yield get_data_from_file(f))
+          f.rewind
+          f.write(dump(result)) if result
+        end
+      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 Exception => e
+        NewRelic::Control.instance.log.error("Error serializing data to disk: #{e.inspect}")
+        NewRelic::Control.instance.log.debug(e.backtrace.split("\n"))
+      end
+
+      def get_data_from_file(f)
+        data = f.read
+        result = load(data)
+        f.truncate(0)
+        result
+      end
+      
+      def max_size
+        10_000
+      end
+
+      def create_file_if_needed
+        FileUtils.touch(file_path) unless File.exists?(file_path)
+      end
+
+      def dump(object)
+        Marshal.dump(object)
+      end
+
+      def load(dump)
+        Marshal.load(dump)
+      rescue ArgumentError => e
+        nil
+      end
+
+      def truncate_file
+        create_file_if_needed
+        File.truncate(file_path, 0)
+      end
+
+      def file_path
+        # TODO get configuration from main control
+        './log/newrelic_agent_store.db'
+      end
+    end
+    extend ClassMethods
+  end
+end
+

data/lib/new_relic/delayed_job_injection.rb

@@ -0,0 +1,38 @@
+require 'dependency_detection'
+# This installs some code to manually start the agent when a delayed
+# job worker starts.  It's not really instrumentation.  It's more like
+# a hook from DJ to the Ruby Agent so it gets loaded at the time the
+# Ruby Agent initializes, which must be before the DJ worker
+# initializes.  Loaded from control.rb
+module NewRelic
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end
+
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Worker)
+  end
+
+  executes do
+    Delayed::Worker.class_eval do
+      def initialize_with_new_relic(*args)
+        initialize_without_new_relic(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+        say "New Relic Ruby Agent Monitoring DJ worker #{dispatcher_instance_id}"
+        NewRelic::DelayedJobInjection.worker_name = worker_name
+        NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+      end
+
+      alias initialize_without_new_relic initialize
+      alias initialize initialize_with_new_relic
+    end
+  end
+end
+DependencyDetection.detect!

data/lib/new_relic/histogram.rb

@@ -0,0 +1,91 @@
+# Histogram is used for organizing response times
+# into an 'Exponential Histogram'.  Feature based in part on DHH proposal:
+# http://37signals.com/svn/posts/1836-the-problem-with-averages
+#
+# Histogram builds a set of buckets of geometrically growing size, with the assumption that most
+# apps have long-tail response times, and therefore you need the most granularity at the lowest
+# r/t level.
+module NewRelic
+  class Histogram
+
+    # Used to stub out API methods when the agent is not enabled
+    module Shim
+      def process(response_time); end
+    end
+    # Stores statistics for response times falling in a particular range.
+    # A bucket has a min and max response time.  A response time event
+    # falls in a bucket if min <= r/t < max.  A bucket also
+    # has an associated metric for reporting data to New Relic.  The
+    # bucket range is encoded in the metic name
+    class Bucket
+
+      attr_reader :min, :max, :stats
+
+      def initialize(min, max = nil)
+        @min = min
+        @max = max
+      end
+
+      def stats
+        NewRelic::Agent.get_stats("Response Times/#{min_millis}/#{max_millis}")
+      end
+
+      # This has return value like <=> but does something more
+      # than simply compare.  If the value falls within range for
+      # the bucket, increment count and return 0; otherwise return
+      # a value < 0 if the value belongs in a bucket with a lower range
+      # you can guess what it returns if the value belongs in a bucket
+      # with a higher range. (Hint: it's not 0, and it's not less than zero.)
+      def process(value)
+        if value < min
+          return -1
+
+          # max == nil means unlimited max (last bucket)
+        elsif max && value >= max
+          return 1
+
+        else
+          stats.record_data_point(value)
+          return 0
+        end
+      end
+
+      def min_millis
+        (min * 1000).round
+      end
+
+      def max_millis
+        max.nil? ? nil : (max * 1000).round
+      end
+
+      def to_s
+        "#{min_millis} - #{max_millis}: #{stats.call_count}"
+      end
+    end
+
+    attr_reader :buckets
+
+    # Histogram uses apdex T / 10 as its minimum bucket size, and grows from there.
+    # 30 data points should be adequate resolution.
+    def initialize(first_bucket_max = 0.010, bucket_count = 30, multiplier = 1.3)
+      @buckets = []
+
+      min = 0
+      max = first_bucket_max
+
+      (bucket_count - 1).times do
+        @buckets << Bucket.new(min, max)
+        min = max
+        max *= multiplier
+      end
+      @buckets << Bucket.new(max)
+    end
+
+    def process(response_time)
+      buckets.each do |bucket|
+        found = bucket.process(response_time)
+        return if found == 0
+      end
+    end
+  end
+end

data/lib/new_relic/local_environment.rb

@@ -0,0 +1,391 @@
+require 'set'
+require 'new_relic/version'
+
+module NewRelic
+  # An instance of LocalEnvironment is responsible for determining
+  # three things:
+  #
+  # * Framework - :rails, :rails3, :merb, :ruby, :external, :test
+  # * Dispatcher - A supported dispatcher, or nil (:mongrel, :thin, :passenger, :webrick, etc)
+  # * Dispatcher Instance ID, which distinguishes agents on a single host from each other
+  #
+  # If the environment can't be determined, it will be set to
+  # nil and dispatcher_instance_id will have nil.
+  #
+  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
+  class LocalEnvironment
+
+    attr_accessor :dispatcher # mongrel, thin, webrick, or possibly nil
+    attr_accessor :dispatcher_instance_id # used to distinguish instances of a dispatcher from each other, may be nil
+    attr_accessor :framework # rails, rails3, merb, external, ruby, test
+    attr_reader :mongrel    # The mongrel instance, if there is one, captured as a convenience
+    attr_reader :processors # The number of cpus, if detected, or nil
+    alias environment dispatcher
+
+    def initialize
+      # Extend self with any any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new framworks and dispatchers.
+      NewRelic::LocalEnvironment.constants.each do | const |
+        mod = NewRelic::LocalEnvironment.const_get const
+        self.extend mod if mod.instance_of? Module
+      end
+
+      discover_framework
+      discover_dispatcher
+      @dispatcher = nil if @dispatcher == :none
+      @gems = Set.new
+      @plugins = Set.new
+      @config = Hash.new
+    end
+
+    # Add the given key/value pair to the app environment
+    # settings.  Must pass either a value or a block.  Block
+    # is called to get the value and any raised errors are
+    # silently ignored.
+    def append_environment_value(name, value = nil)
+      value = yield if block_given?
+      @config[name] = value if value
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+
+    def append_gem_list
+      @gems += yield
+    rescue Exception => e
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+
+    def append_plugin_list
+      @plugins += yield
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+
+    def dispatcher_instance_id
+      if @dispatcher_instance_id.nil?
+        if @dispatcher.nil?
+          @dispatcher_instance_id = File.basename($0).split(".").first
+        end
+      end
+      @dispatcher_instance_id
+    end
+
+    def gather_ruby_info
+      append_environment_value('Ruby version'){ RUBY_VERSION }
+      append_environment_value('Ruby description'){ RUBY_DESCRIPTION } if defined? ::RUBY_DESCRIPTION
+      append_environment_value('Ruby platform') { RUBY_PLATFORM }
+      append_environment_value('Ruby patchlevel') { RUBY_PATCHLEVEL }
+      # room here for other ruby implementations, when.
+      if defined? ::JRUBY_VERSION
+        gather_jruby_info
+      end
+    end
+
+    def gather_jruby_info
+      append_environment_value('JRuby version') { JRUBY_VERSION }
+      append_environment_value('Java VM version') { ENV_JAVA['java.vm.version']}
+    end
+
+    # See what the number of cpus is, works only on linux.
+    def gather_cpu_info
+      return unless File.readable? '/proc/cpuinfo'
+      @processors = append_environment_value('Processors') do
+        processors = File.readlines('/proc/cpuinfo').select { |line| line =~ /^processor\s*:/ }.size
+        raise "Cannot determine the number of processors in /proc/cpuinfo" unless processors > 0
+        processors
+      end
+    end
+
+    def gather_architecture_info
+      append_environment_value('Arch') { `uname -p` } ||
+        append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
+    end
+
+    def gather_os_info
+      append_environment_value('OS version') { `uname -v` }
+      append_environment_value('OS') { `uname -s` } ||
+        append_environment_value('OS') { ENV['OS'] }
+    end
+
+    def gather_system_info
+      gather_architecture_info
+      gather_cpu_info
+    end
+
+    def gather_revision_info
+      # Look for a capistrano file indicating the current revision:
+      rev_file = File.join(NewRelic::Control.instance.root, "REVISION")
+      if File.readable?(rev_file) && File.size(rev_file) < 64
+        append_environment_value('Revision') do
+          File.open(rev_file) { | file | file.readline.strip }
+        end
+      end
+    end
+
+    def gather_ar_adapter_info
+      # The name of the database adapter for the current environment.
+      append_environment_value 'Database adapter' do
+        if defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.respond_to?(:configurations)
+          config = ActiveRecord::Base.configurations[NewRelic::Control.instance.env]
+          if config
+            config['adapter']
+          end
+        end
+      end
+      append_environment_value 'Database schema version' do
+        ActiveRecord::Migrator.current_version
+      end
+    end
+
+    def gather_dm_adapter_info
+      append_environment_value 'DataMapper version' do
+        require 'dm-core/version'
+        DataMapper::VERSION
+      end
+    end
+
+    def gather_db_info
+      # room here for more database adapters, when.
+      if defined? ::ActiveRecord
+        gather_ar_adapter_info
+      end
+      if defined? ::DataMapper
+        gather_dm_adapter_info
+      end
+    end
+
+    # Collect base statistics about the environment and record them for
+    # comparison and change detection.
+    def gather_environment_info
+      append_environment_value 'Framework', @framework.to_s
+      append_environment_value 'Dispatcher', @dispatcher.to_s if @dispatcher
+      append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
+      append_environment_value('Environment') { NewRelic::Control.instance.env }
+
+      # miscellaneous other helpful debugging information
+      gather_ruby_info
+      gather_system_info
+      gather_revision_info
+      gather_db_info
+    end
+
+    # Take a snapshot of the environment information for this application
+    # Returns an associative array
+    def snapshot
+      i = @config.to_a
+      i << [ 'Plugin List', @plugins.to_a] if not @plugins.empty?
+      i << [ 'Gems', @gems.to_a] if not @gems.empty?
+      i
+    end
+
+    def working_jruby?
+      !(defined?(::JRuby) && JRuby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
+    end
+
+    def find_class_in_object_space(klass)
+      ObjectSpace.each_object(klass) do |x|
+        return x
+      end
+    end
+
+    def mongrel
+      return @mongrel if @mongrel
+      if defined?(::Mongrel) && defined?(::Mongrel::HttpServer) && working_jruby?
+        @mongrel = find_class_in_object_space(::Mongrel::HttpServer)
+      end
+      @mongrel
+    end
+
+    def unicorn
+      return @unicorn if @unicorn
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
+        @unicorn = find_class_in_object_space(::Unicorn::HttpServer)
+      end
+      @unicorn
+    end
+
+    private
+
+    # Although you can override the framework with NEWRELIC_DISPATCHER this
+    # is not advisable since it implies certain api's being available.
+    def discover_dispatcher
+      @dispatcher ||= ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
+      dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
+      while dispatchers.any? && @dispatcher.nil?
+        send 'check_for_'+(dispatchers.shift)
+      end
+    end
+
+    def discover_framework
+      # Although you can override the framework with NEWRELIC_FRAMEWORK this
+      # is not advisable since it implies certain api's being available.
+      #
+      # Note that the odd defined? sequence is necessary to work around a bug in an older version
+      # of JRuby.
+      @framework ||= case
+                     when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
+                     when defined?(::NewRelic::TEST) then :test
+                     when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
+                     when defined?(::Rails) then check_rails_version
+                     when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+                     when defined?(::NewRelic::IA) then :external
+                     else :ruby
+                     end
+    end
+
+    def check_rails_version
+      if Rails::VERSION::MAJOR < 3
+        :rails
+      else
+        :rails3
+      end
+    end
+
+    def check_for_torquebox
+      return unless defined?(::JRuby) &&
+         ( org.torquebox::TorqueBox rescue nil)
+      @dispatcher = :torquebox
+    end
+
+    def check_for_glassfish
+      return unless defined?(::JRuby) &&
+        (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+          defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
+         (jruby_rack? && defined?(::GlassFish::Server)))
+      @dispatcher = :glassfish
+    end
+
+    def check_for_trinidad
+      return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+      @dispatcher = :trinidad
+    end
+
+    def jruby_rack?
+      ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+       defined?(org::jruby::rack::DefaultRackApplicationFactory))
+    end
+
+    def check_for_webrick
+      return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      @dispatcher = :webrick
+      if defined?(::OPTIONS) && OPTIONS.respond_to?(:fetch)
+        # OPTIONS is set by script/server
+        @dispatcher_instance_id = OPTIONS.fetch(:port)
+      end
+      @dispatcher_instance_id = default_port unless @dispatcher_instance_id
+    end
+
+    def check_for_fastcgi
+      return unless defined?(::FCGI)
+      @dispatcher = :fastcgi
+    end
+
+    # this case covers starting by mongrel_rails
+    def check_for_mongrel
+      return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+      @dispatcher = :mongrel
+
+      # Get the port from the server if it's started
+
+      if mongrel && mongrel.respond_to?(:port)
+        @dispatcher_instance_id = mongrel.port.to_s
+      end
+
+      # Get the port from the configurator if one was created
+      if @dispatcher_instance_id.nil? && defined?(::Mongrel::Configurator)
+        ObjectSpace.each_object(Mongrel::Configurator) do |mongrel|
+          @dispatcher_instance_id = mongrel.defaults[:port] && mongrel.defaults[:port].to_s
+        end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
+      end
+
+      # Still can't find the port.  Let's look at ARGV to fall back
+      @dispatcher_instance_id = default_port if @dispatcher_instance_id.nil?
+    end
+
+    def check_for_unicorn
+      return unless defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
+
+      # unlike mongrel, unicorn manages muliple threads and ports, so we
+      # have to map multiple processes into one instance, as we do with passenger
+      @dispatcher = :unicorn
+    end
+
+    def check_for_sinatra
+      return unless defined?(::Sinatra) && defined?(::Sinatra::Base)
+
+      begin
+        version = ::Sinatra::VERSION
+      rescue
+        $stderr.puts("Error determining Sinatra version")
+      end
+
+      if ::NewRelic::VersionNumber.new('0.9.2') > version
+        $stderr.puts("Your Sinatra version is #{version}, we highly recommend upgrading to >=0.9.2")
+      end
+
+      @dispatcher = :sinatra
+    end
+
+    def check_for_thin
+      if defined?(::Thin) && defined?(::Thin::Server)
+        # This case covers the thin web dispatcher
+        # Same issue as above- we assume only one instance per process
+        ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
+          @dispatcher = :thin
+          backend = thin_dispatcher.backend
+          # We need a way to uniquely identify and distinguish agents.  The port
+          # works for this.  When using sockets, use the socket file name.
+          if backend.respond_to? :port
+            @dispatcher_instance_id = backend.port
+          elsif backend.respond_to? :socket
+            @dispatcher_instance_id = backend.socket
+          else
+            raise "Unknown thin backend: #{backend}"
+          end
+        end # each thin instance
+      end
+      if defined?(::Thin) && defined?(::Thin::VERSION) && !@dispatcher
+        @dispatcher = :thin
+        @dispatcher_instance_id = default_port
+      end
+    end
+
+    def check_for_litespeed
+      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+        @dispatcher = :litespeed
+      end
+    end
+
+    def check_for_passenger
+      if (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
+        @dispatcher = :passenger
+      end
+    end
+
+
+    def default_port
+      require 'optparse'
+      # If nothing else is found, use the 3000 default
+      default_port = 3000
+      OptionParser.new do |opts|
+        opts.on("-p", "--port=port", String) { | p | default_port = p }
+        opts.parse(ARGV.clone) rescue nil
+      end
+      default_port
+    end
+
+    public
+    def to_s
+      s = "LocalEnvironment["
+      s << @framework.to_s
+      s << ";dispatcher=#{@dispatcher}" if @dispatcher
+      s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
+      s << "]"
+    end
+
+  end
+end