dolores_rpm 3.2.0.2

data/lib/new_relic/local_environment.rb

@@ -0,0 +1,414 @@
+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
+    
+    # mongrel, thin, webrick, or possibly nil
+    attr_accessor :dispatcher
+    # used to distinguish instances of a dispatcher from each other, may be nil
+    attr_writer :dispatcher_instance_id
+    # rails, rails3, merb, external, ruby, test, etc
+    attr_accessor :framework
+    # The number of cpus, if detected, or nil - many platforms do not
+    # support this :(
+    attr_reader :processors 
+    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
+    
+    # yields to the block and appends the returned value to the list
+    # of gems - this catches errors that might be raised in the block
+    def append_gem_list
+      @gems += yield
+    rescue Exception => e
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+    
+    # yields to the block and appends the returned value to the list
+    # of plugins - this catches errors that might be raised in the block
+    def append_plugin_list
+      @plugins += yield
+    rescue Exception
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+    
+    # An instance id pulled from either @dispatcher_instance_id or by
+    # splitting out the first part of the running file
+    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
+    
+    # Interrogates some common ruby constants for useful information
+    # about what kind of ruby environment the agent is running in
+    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
+    
+    # like gather_ruby_info but for the special case of JRuby
+    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 some linux variants
+    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
+    
+    # Grabs the architecture string from either `uname -p` or the env
+    # variable PROCESSOR_ARCHITECTURE
+    def gather_architecture_info
+      append_environment_value('Arch') { `uname -p` } ||
+        append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
+    end
+    
+    # gathers OS info from either `uname -v`, `uname -s`, or the OS
+    # env variable
+    def gather_os_info
+      append_environment_value('OS version') { `uname -v` }
+      append_environment_value('OS') { `uname -s` } ||
+        append_environment_value('OS') { ENV['OS'] }
+    end
+    
+    # Gathers the architecture and cpu info
+    def gather_system_info
+      gather_architecture_info
+      gather_cpu_info
+    end
+    
+    # Looks for a capistrano file indicating the current revision
+    def gather_revision_info
+      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
+    
+    # The name of the AR database adapter for the current environment and
+    # the current schema version
+    def gather_ar_adapter_info
+      
+      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
+    
+    # Datamapper version
+    def gather_dm_adapter_info
+      append_environment_value 'DataMapper version' do
+        require 'dm-core/version'
+        DataMapper::VERSION
+      end
+    end
+    
+    # sensing for which adapter is defined, then appends the relevant
+    # config information
+    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
+    
+    # it's a working jruby if it has the runtime method, and object
+    # space is enabled
+    def working_jruby?
+      !(defined?(::JRuby) && JRuby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
+    end
+    
+    # Runs through all the objects in ObjectSpace to find the first one that
+    # match the provided class
+    def find_class_in_object_space(klass)
+      ObjectSpace.each_object(klass) do |x|
+        return x
+      end
+      return nil
+    end
+    
+    # Sets the @mongrel instance variable if we can find a Mongrel::HttpServer
+    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
+    
+    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
+      @dispatcher ||= ENV['NEW_RELIC_DISPATCHER'] && ENV['NEW_RELIC_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 ENV['NEW_RELIC_FRAMEWORK'] then ENV['NEW_RELIC_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
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
+        v = find_class_in_object_space(::Unicorn::HttpServer)
+        @dispatcher = :unicorn if v 
+      end
+    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
+    # outputs a human-readable description
+    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

data/lib/new_relic/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :newrelic do
+  desc "Install the developer mode newrelic.yml file"
+  task :default do
+    load File.expand_path(File.join(__FILE__,"..","..","install.rb"))
+  end
+end

data/lib/new_relic/metric_data.rb

@@ -0,0 +1,51 @@
+module NewRelic
+  class MetricData
+    # nil, or a NewRelic::MetricSpec object if we have no cached ID
+    attr_accessor :metric_spec
+    # nil or a cached integer ID for the metric from the collector.
+    attr_accessor :metric_id
+    # the actual statistics object
+    attr_accessor :stats
+
+    def initialize(metric_spec, stats, metric_id)
+      @metric_spec = metric_spec
+      self.stats = stats
+      self.metric_id = metric_id
+    end
+
+    def eql?(o)
+     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+    end
+
+    def original_spec
+      @original_spec || @metric_spec
+    end
+    
+    # assigns a new metric spec, and retains the old metric spec as
+    # @original_spec if it exists currently
+    def metric_spec= new_spec
+      @original_spec = @metric_spec if @metric_spec
+      @metric_spec = new_spec
+    end
+
+    def hash
+      metric_spec.hash ^ stats.hash
+    end
+
+    # Serialize with all attributes, but if the metric id is not nil, then don't send the metric spec
+    def to_json(*a)
+       %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
+    end
+    
+    def to_s
+      if metric_spec
+        "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
+      else
+        "#{metric_id}: #{stats}"
+      end
+    end
+    def inspect
+      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
+    end
+  end
+end

data/lib/new_relic/metric_spec.rb

@@ -0,0 +1,75 @@
+# this struct uniquely defines a metric, optionally inside
+# the call scope of another metric
+class NewRelic::MetricSpec
+  attr_accessor   :name
+  attr_accessor   :scope
+  
+  # the maximum length of a metric name or metric scope
+  MAX_LENGTH = 255
+  # Need a "zero-arg" constructor so it can be instantiated from java (using
+  # jruby) for sending responses to ruby agents from the java collector.
+  #
+  def initialize(metric_name = '', metric_scope = '')
+    self.name = (metric_name || '') && metric_name[0...MAX_LENGTH]
+    self.scope = metric_scope && metric_scope[0...MAX_LENGTH]
+  end
+  
+  # truncates the name and scope to the MAX_LENGTH
+  def truncate!
+    self.name = name[0...MAX_LENGTH] if name && name.size > MAX_LENGTH
+    self.scope = scope[0...MAX_LENGTH] if scope && scope.size > MAX_LENGTH
+  end
+  
+  def ==(o)
+    self.eql?(o)
+  end
+
+  def eql? o
+    self.class == o.class &&
+    name.eql?(o.name) &&
+    # coerce scope to a string and compare
+     scope.to_s == o.scope.to_s
+  end
+
+  def hash
+    h = name.hash
+    h ^= scope.hash unless scope.nil?
+    h
+  end
+  # return a new metric spec if the given regex
+  # matches the name or scope.
+  def sub(pattern, replacement, apply_to_scope = true)
+    NewRelic::Control.instance.log.warn("The sub method on metric specs is deprecated") rescue nil
+    return nil if name !~ pattern &&
+     (!apply_to_scope || scope.nil? || scope !~ pattern)
+    new_name = name.sub(pattern, replacement)[0...MAX_LENGTH]
+
+    if apply_to_scope
+      new_scope = (scope && scope.sub(pattern, replacement)[0...MAX_LENGTH])
+    else
+      new_scope = scope
+    end
+
+    self.class.new new_name, new_scope
+  end
+
+  def to_s
+    return name if scope.empty?
+    "#{name}:#{scope}"
+  end
+
+  def inspect
+    "#<NewRelic::MetricSpec '#{name}':'#{scope}'>"
+  end
+
+  def to_json(*a)
+    {'name' => name,
+    'scope' => scope}.to_json(*a)
+  end
+
+  def <=>(o)
+    namecmp = self.name <=> o.name
+    return namecmp if namecmp != 0
+    return (self.scope || '') <=> (o.scope || '')
+  end
+end

data/lib/new_relic/metrics.rb

@@ -0,0 +1,9 @@
+module NewRelic
+  module Metrics
+    CONTROLLER = "Controller"
+    DISPATCHER = "HttpDispatcher"
+    ACTIVE_RECORD = "ActiveRecord"
+    USER_TIME = "CPU/User Time"
+    MEMORY = "Memory/Physical"
+  end
+end

data/lib/new_relic/noticed_error.rb

@@ -0,0 +1,24 @@
+# This class encapsulates an error that was noticed by New Relic in a managed app.
+class NewRelic::NoticedError
+  extend NewRelic::CollectionHelper
+  attr_accessor :path, :timestamp, :params, :exception_class, :message
+
+  def initialize(path, data, exception, timestamp = Time.now)
+    self.path = path
+    self.params = NewRelic::NoticedError.normalize_params(data)
+
+    self.exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
+
+    if exception.respond_to?('original_exception')
+      self.message = exception.original_exception.message.to_s
+    else
+      self.message = (exception || '<no message>').to_s
+    end
+
+    # clamp long messages to 4k so that we don't send a lot of
+    # overhead across the wire
+    self.message = self.message[0..4095] if self.message.length > 4096
+
+    self.timestamp = timestamp
+  end
+end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -0,0 +1,68 @@
+require 'rack'
+
+module NewRelic::Rack
+  class BrowserMonitoring
+
+    def initialize(app, options = {})
+      @app = app
+    end
+
+    # method required by Rack interface
+    def call(env)
+      
+      # clear out the thread locals we use in case this is a static request
+      Thread.current[:newrelic_most_recent_transaction] = nil
+      Thread.current[:newrelic_start_time] = Time.now
+      Thread.current[:newrelic_queue_time] = 0
+      
+      result = @app.call(env)   # [status, headers, response]
+
+      if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(result[0], result[1])
+        response_string = autoinstrument_source(result[2], result[1])
+
+        if (response_string)
+          Rack::Response.new(response_string, result[0], result[1]).finish
+        else
+          result
+        end
+      else
+        result
+      end
+    end
+
+    def should_instrument?(status, headers)
+      status == 200 && headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+    end
+
+    def autoinstrument_source(response, headers)
+      source = nil
+      response.each {|fragment| (source) ? (source << fragment) : (source = fragment)}
+      return nil unless source
+      
+      body_start = source.index("<body")
+      body_close = source.rindex("</body>")
+
+      if body_start && body_close
+        footer = NewRelic::Agent.browser_timing_footer
+        header = NewRelic::Agent.browser_timing_header
+                  
+        if source.include?('X-UA-Compatible')
+          # put at end of header if UA-Compatible meta tag found
+          head_pos = source.index("</head>")          
+        elsif head_open = source.index("<head")
+          # put at the beginning of the header
+          head_pos = source.index(">", head_open) + 1
+        else
+          # put the header right above body start
+          head_pos = body_start
+        end
+
+        source = source[0..(head_pos-1)] + header + source[head_pos..(body_close-1)] + footer + source[body_close..-1]
+
+        headers['Content-Length'] = source.length.to_s if headers['Content-Length']
+      end
+
+      source
+    end
+  end
+end