newrelic_rpm 2.8.11 → 2.9.2

data/README

@@ -1,136 +0,0 @@
-= New Relic RPM
-
-* http://www.newrelic.com
-
-New Relic RPM is a Ruby performance management system, developed by
-New Relic, Inc.  RPM provides you with deep information about the
-performance of your Ruby on Rails or Merb application as it runs in
-production. The New Relic Agent is distributed as a either a Rails
-plugin or a Gem, both hosted on RubyForge.
-
-The New Relic Agent runs in one of two modes:
-
-* Developer Mode : Adds a web interface mapped to /newrelic to your
-  application for showing detailed performance metrics on a page by
-  page basis.
-  
-* Production Mode : Low overhead instrumentation that captures
-  detailed information on your application running in production and
-  transmits them to rpm.newrelic.com where you can monitor them in
-  real time.
-
-=== Developer Mode
-
-Developer mode is on by default when you run your application in the
-development environment (but not when it runs in other environments.)
-When running in developer mode, RPM will track the performance of
-every http request serviced by your application, and store in memory
-this information for the last 100 http transactions.
-
-When running in Developer Mode, the RPM will also add a few pages to
-your application that allow you to analyze this performance
-information. (Don't worry - those pages are not added to your
-application's routes when you run in production mode.)
-
-To view this performance information, including detailed SQL statement
-analysis, open '/newrelic' in your web application.  For instance if
-you are running mongrel or thin on port 3000, enter the following into
-your browser:
-
-http://localhost:3000/newrelic
-
-=== Production Mode
-
-To monitor your applications in production, create an account at
-http://newrelic.com/get-RPM.html
-
-When your application runs in the production environment, the New
-Relic agent runs in production mode. It connects to the New Relic RPM
-service and sends deep performance data to the RPM service for your
-analysis. To view this data, login to http://rpm.newrelic.com.
-
-NOTE: You must have a valid account and license key to view this data
-online.  When you sign up for an account at www.newrelic.com, you will
-be provided with a license key, as well as a default configuration
-file for New Relic RPM. You can either paste your license key into
-your existing configuration file, config/newrelic.yml, or you can
-replace that config file with the one included in your welcome email.
-
-== Installation
-
-RPM requires an agent be installed in the application as either a
-Rails plug-in or a gem.  Both are available on RubyForge--instructions
-below.
-
-=== Git your RPM on!
-
-The agent is also available on Github under newrelic/rpm. As of March,
-2009, we keep the latest release on the master, the edge on a working
-branch, and previous releases with tags.  Fork away!
-
-=== Requirements:
-
-Ruby 1.8.6
-Rails 1.2.6 or above
-Merb 1.0 or above
-
-=== Rails Plug-In Installation
-
-   script/plugin install http://newrelic.rubyforge.org/svn/newrelic_rpm
-   
-=== Gem Installation
-
-   sudo gem install newrelic_rpm
-
-For Rails, edit environment.rb and add to the initalizer block:
-
-   config.gem "newrelic_rpm" 
-
-The Developer Mode is unavailable when using the gem on Rails versions
-prior to 2.0.
-
-== Merb Support
-
-To monitor a merb app install the newrelic_rpm gem and add
-
-    dependency 'newrelic_rpm'
-
-to your init.rb file.
-
-Current features implemented:
-
-    * Standard monitoring, overview pages
-    * Error capturing
-    * Full Active Record instrumentation, including SQL explains
-    * Very limited Data Mapper instrumentation
-    * Transaction Traces are implemented but will not be very useful
-      with Data Mapper until more work is done with the Data Mapper
-      instrumentation
-
-Still under development:
-
-    * Developer Mode
-    * Data Mapper bindings
-
-Also some of the instrumentation has been implemented with method
-chaining, a mechanism that truly goes against the merb way. This was
-necessary in some cases where the API’s were not yet available or
-understood well enough to use. Converting these to hook methods using
-the Merb public API is a work in progress.
-
-== Support
-
-Reach out to us--and to fellow RPM users--at
-http://support.newrelic.com.  There you'll find documentation, FAQs,
-and forums where you can submit suggestions and discuss RPM with New
-Relic staff and other users.
-
-Find a bug?  E-mail support@newrelic.com, or post it to
-support.newrelic.com.
-
-For other support channels, see http://www.newrelic.com/support.
-
-Thank you, and may your application scale to infinity plus one.  
-
-Lew Cirne, Founder and CEO
-New Relic, Inc.

data/lib/new_relic/agent/instrumentation/rails/rails.rb

@@ -1,6 +0,0 @@
-# Instrument the compilation of ERB files. 
-ERB::Compiler.class_eval do
-  add_method_tracer :compile, 'View/.rhtml Processing'
-end
-
-

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

@@ -1,29 +0,0 @@
-module NewRelic::Agent
-  class CPUSampler
-    def initialize
-  
-      agent = NewRelic::Agent.instance
-  
-      agent.stats_engine.add_sampled_metric("CPU/User Time") do | stats |
-        t = Process.times
-        @last_utime ||= t.utime
-        
-        utime = t.utime
-        stats.record_data_point(utime - @last_utime) if (utime - @last_utime) >= 0
-        @last_utime = utime
-      end
-  
-      agent.stats_engine.add_sampled_metric("CPU/System Time") do | stats |
-        t = Process.times
-        @last_stime ||= t.stime
-        
-        stime = t.stime
-        stats.record_data_point(stime - @last_stime) if (stime - @last_stime) >= 0
-        @last_stime = stime
-      end
-    end
-  end
-end
-
-# CPU sampling like this doesn't work for jruby
-NewRelic::Agent::CPUSampler.new unless defined? Java

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

@@ -1,53 +0,0 @@
-module NewRelic::Agent
-  class MemorySampler
-    def initialize
-      if RUBY_PLATFORM =~ /java/
-        platform = %x[uname -s].downcase
-      else
-        platform = RUBY_PLATFORM.downcase
-      end
-      
-      # macos, linux, solaris
-      if platform =~ /darwin|linux/
-        @ps = "ps -o rsz"
-      elsif platform =~ /freebsd/
-        @ps = "ps -o rss"
-      elsif platform =~ /solaris/
-        @ps = "/usr/bin/ps -o rss -p"
-      end
-      if !@ps
-        NewRelic::Config.instance.log.warn "Unsupported platform for getting memory: #{platform}"
-      else
-        @broken = false
-        
-        agent = NewRelic::Agent.instance        
-        agent.stats_engine.add_sampled_metric("Memory/Physical") do |stats|
-          if !@broken
-            begin
-              process = $$
-              memory = `#{@ps} #{process}`.split("\n")[1].to_f / 1024
-
-              # if for some reason the ps command doesn't work on the resident os,
-              # then don't execute it any more.
-              if memory >= 0
-                stats.record_data_point memory
-              else 
-                NewRelic::Agent.instance.log.error "Error attempting to determine resident memory for pid #{process} (got result of #{memory}, this process = #{$$}).  Disabling this metric."
-                NewRelic::Agent.instance.log.error "Faulty command: `#{@ps}`"
-                @broken = true
-              end
-            rescue Exception => e
-              if e.is_a? Errno::ENOMEM
-                NewRelic::Agent.instance.log.error "Got OOM trying to determine process memory usage"
-              else
-                raise e
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-NewRelic::Agent::MemorySampler.new

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

@@ -1,26 +0,0 @@
-# NewRelic Instrumentation for Mongrel - tracks the queue length of the mongrel server
-if defined? Mongrel::HttpServer
-  
-  agent = NewRelic::Agent.instance
-  mongrel = nil;
-  ObjectSpace.each_object(Mongrel::HttpServer) do |mongrel_instance|
-    # should only be one mongrel instance in the vm
-    if mongrel
-      agent.log.info("Discovered multiple mongrel instances in one Ruby VM.  "+
-        "This is unexpected and might affect the Accuracy of the Mongrel Request Queue metric.")
-    end
-
-    mongrel = mongrel_instance
-  end
-  
-
-  if mongrel
-    agent.stats_engine.add_sampled_metric("Mongrel/Queue Length") do |stats|
-      qsize = mongrel.workers.list.length
-      qsize -= 1 if NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
-      qsize = 0 if qsize < 0
-      stats.record_data_point qsize
-    end
-  end
-
-end

data/lib/new_relic/agent/synchronize.rb

@@ -1,40 +0,0 @@
-
-module NewRelic::Agent
-  
-  module Synchronize
-    def synchronize_sync
-      @_local_sync ||= Sync.new
-      
-      @_local_sync.synchronize(:EX) do
-        yield
-      end
-    end
-    
-    
-    def synchronize_mutex
-      @_local_mutex ||= Mutex.new
-      
-      @_local_mutex.synchronize do
-        yield
-      end
-    end
-  
-    
-    def synchronize_thread
-      old_val = Thread.critical
-      
-      Thread.critical = true
-      
-      begin
-        yield
-      ensure
-        Thread.critical = old_val
-      end
-    end
-    
-    
-    alias synchronize synchronize_mutex
-    alias synchronize_quick synchronize_mutex
-    alias synchronized_long synchronize_mutex
-  end   
-end

data/lib/new_relic/config/merb.rb

@@ -1,35 +0,0 @@
-class NewRelic::Config::Merb < NewRelic::Config
-  
-  def app; :merb; end
-  
-  def env
-    @env ||= ::Merb.env
-  end
-  def root 
-    ::Merb.root
-  end
-  
-  def to_stderr(msg)
-    STDERR.puts "NewRelic ~ " + msg 
-  end
-  
-  def start_plugin
-    ::Merb::Plugins.add_rakefiles File.join(newrelic_root,"lib/tasks/all.rb")
-    
-    # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
-    ::Merb::Plugins.config[:newrelic] = {
-      :config => self
-    }
-    
-    ::Merb::BootLoader.before_app_loads do
-      # require code that must be loaded before the application
-    end
-    
-    if tracers_enabled?
-      ::Merb::BootLoader.after_app_loads do
-        start_agent
-      end
-    end
-    
-  end
-end

data/lib/new_relic/config/rails.rb

@@ -1,114 +0,0 @@
-class NewRelic::Config::Rails < NewRelic::Config
-  
-  def app; :rails; end
-  
-  def env
-    @env ||= RAILS_ENV
-  end
-  def root
-    RAILS_ROOT
-  end
-  
-  def log_path
-    path = ::RAILS_DEFAULT_LOGGER.instance_eval do
-      File.dirname(@log.path) rescue File.dirname(@logdev.filename) 
-    end rescue "#{root}/log"
-    File.expand_path(path)
-  end
-  
-  def start_plugin(rails_config=nil)
-    if !tracers_enabled? || !start_agent
-      require 'new_relic/shim_agent'
-    else
-      install_developer_mode rails_config if developer_mode?
-    end
-  end
-  
-  def install_developer_mode(rails_config)
-    controller_path = File.join(newrelic_root, 'ui', 'controllers')
-    helper_path = File.join(newrelic_root, 'ui', 'helpers')
-
-    if defined? ActiveSupport::Dependencies
-      Dir["#{helper_path}/*.rb"].each { |f| require f }
-      Dir["#{controller_path}/*.rb"].each { |f| require f }
-    elsif defined? Dependencies.load_paths
-      Dependencies.load_paths << controller_path
-      Dependencies.load_paths << helper_path
-    else
-      to_stderr "ERROR: Rails version #{(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION : ''} too old for developer mode to work."
-      return
-    end
-    
-    install_devmode_route
-    
-    
-    # If we have the config object then add the controller path to the list.
-    # Otherwise we have to assume the controller paths have already been
-    # set and we can just append newrelic.
-    
-    if rails_config
-      rails_config.controller_paths << controller_path
-    else
-      current_paths = ActionController::Routing.controller_paths
-      if current_paths.nil? || current_paths.empty?
-        to_stderr "WARNING: Unable to modify the routes in this version of Rails.  Developer mode not available."
-      end
-      current_paths << controller_path
-    end
-    
-    #ActionController::Routing::Routes.reload! unless NewRelic::Config.instance['skip_developer_route']
-    
-    # inform user that the dev edition is available if we are running inside
-    # a webserver process
-    if local_env.identifier
-      port = local_env.identifier.to_s =~ /^\d+/ ? ":#{local_env.identifier}" : ":port" 
-      to_stderr "NewRelic Agent Developer Mode enabled."
-      to_stderr "To view performance information, go to http://localhost#{port}/newrelic"
-    end
-  end
-  
-  protected 
-  
-  def install_devmode_route
-    # This is a monkey patch to inject the developer tool route into the
-    # parent app without requiring users to modify their routes. Of course this 
-    # has the effect of adding a route indiscriminately which is frowned upon by 
-    # some: http://www.ruby-forum.com/topic/126316#563328
-    ActionController::Routing::RouteSet.class_eval do
-      return false if self.instance_methods.include? 'draw_with_newrelic_map'
-      def draw_with_newrelic_map
-        draw_without_newrelic_map do | map |
-          map.named_route 'newrelic_developer', '/newrelic/:action/:id', :controller => 'newrelic' unless NewRelic::Config.instance['skip_developer_route']
-          yield map        
-        end
-      end
-      alias_method_chain :draw, :newrelic_map
-    end
-    return true
-  end
-  
-  # Collect the Rails::Info into an associative array as well as the list of plugins
-  def gather_info
-    i = [[:app, app]]
-    begin 
-      begin
-        require 'rails/info'
-      rescue LoadError
-        require 'builtin/rails_info/rails/info'
-      end
-      i += ::Rails::Info.properties
-    rescue SecurityError, ScriptError, StandardError => e
-      log.debug "Unable to get the Rails info: #{e.inspect}"
-    end
-    
-    plugins = Dir[File.expand_path(File.join(RAILS_ROOT,"vendor","plugins","*"))].collect { |p| File.basename p }
-    i << ['Plugin List', plugins]
-    
-    # Look for a capistrano file indicating the current revision:
-    rev_file = File.expand_path(File.join(RAILS_ROOT, "REVISION"))
-    if File.readable?(rev_file) && File.size(rev_file) < 64
-      File.open(rev_file) { | file | i << ['Revision', file.read] } rescue nil
-    end
-    i
-  end
-end