newrelic_rpm 2.8.0

data/recipes/newrelic.rb

@@ -0,0 +1,46 @@
+# To be included in Capistrano deploy.rb files
+#
+# Defined deploy:notify_rpm which will send information about the deploy to RPM.
+# The task will run on app servers except where no_release is true.
+# If it fails, it will not affect the task execution or do a rollback.
+#
+
+make_notify_task = lambda do
+  
+  namespace :newrelic do
+    
+    # on all deployments, notify RPM 
+    desc "Record a deployment in New Relic RPM (rpm.newrelic.com)"
+    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
+      rails_env = fetch(:rails_env, "production")
+      from_revision = source.next_revision(current_revision)
+      log_command = source.log(from_revision)
+      # I don't believe this will work if rpm is installed as a gem, or 
+      # if they put the plugin elsewhere.  Need to revisit.
+      script = [ "vendor/plugins/newrelic_rpm/lib/new_relic_api.rb" ] <<
+                 "deployments" <<
+                 "-u" << ENV['USER'] <<
+                 "-r" << current_revision <<
+                 "-c" 
+      script = script.map { | arg | "'#{arg}'" }.join(" ")
+      begin
+        run "cd #{current_release}; #{log_command} | script/runner -e #{rails_env} #{script}" do | io, stream_id, output |
+          logger.trace(output)
+        end
+      rescue CommandError
+        logger.info "unable to notify New Relic of the deployment... skipping"
+      end
+      # For rollbacks, let's update the deployment we created with an indication of the failure:
+      #on_rollback do
+      #  run(command.gsub(/Subject:.*\\n/, "Subject: #{ENV['USER']} deployed a ROLLBACK\\n"))
+      #end
+    end
+  end
+end
+
+instance = Capistrano::Configuration.instance
+if instance
+  instance.load make_notify_task
+else
+  make_notify_task.call
+end

data/test/config/newrelic.yml

@@ -0,0 +1,26 @@
+# This is the config file loaded when running unit tests locally.
+
+test:
+  erb_value: <%= 'hey'*3 %>
+  host: localhost
+  port: 3000
+  log_level: debug
+  capture_params: true
+  enabled: false
+  developer: true
+  monitor_daemons: false
+  message: '<%= generated_for_user %>'
+  license_key: '<%= license_key %>'
+  transaction_tracer:
+    enabled: true
+    record_sql: raw
+    transaction_threshold: 0.500
+    explain_threshold: 0.1
+    explain_enabled: true
+    stack_trace_threshold: 0.1
+    
+  error_collector:
+    enabled: true
+    capture_source: true
+    
+  

data/test/config/test_config.rb

@@ -0,0 +1,9 @@
+require 'new_relic/config/rails'
+class NewRelic::Config::Test < NewRelic::Config::Rails
+  def env
+    'test'
+  end
+  def config_file
+    File.join(File.dirname(__FILE__), "newrelic.yml")
+  end
+end

data/test/new_relic/agent/mock_ar_connection.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  class Base
+    class << self
+      def test_connection(config)
+        @connect ||= Connection.new
+      end
+    end
+  end
+  
+  class Connection
+    attr_accessor :throw
+    attr_reader :disconnected
+    
+    def initialize
+      @disconnected = false
+      @throw = false
+    end
+    
+    def disconnect!()
+      @disconnected = true
+    end
+    
+    def find()
+      # used to test that we've instrumented this...
+    end
+
+    def select_rows(s)
+      execute(s)
+    end
+    def execute(s)
+      fail "" if @throw
+      if s != "EXPLAIN #{::SQL_STATEMENT}"
+        fail "Unexpected sql statement #{s}"        
+      end
+      s
+    end
+  end
+end
+
+

data/test/new_relic/agent/mock_scope_listener.rb

@@ -0,0 +1,23 @@
+
+class NewRelic::Agent::MockScopeListener
+  
+  attr_reader :scope
+  
+  def initialize
+    @scope = {}
+  end
+  
+  def notice_first_scope_push(time)
+  end
+  
+  def notice_push_scope(scope, time)
+    @scope[scope] = true
+  end
+  
+  def notice_pop_scope(scope, time)
+  end
+  
+  def notice_scope_empty(time)
+    
+  end
+end

data/test/new_relic/agent/model_fixture.rb

@@ -0,0 +1,17 @@
+# A test model object 
+# Be sure and call setup and teardown
+class NewRelic::Agent::ModelFixture < ActiveRecord::Base
+  self.table_name = 'test_data'
+  def self.setup
+    connection.create_table :test_data, :force => true do |t|
+      t.column :name, :string
+    end
+    connection.setup_slow
+  end
+  
+  def self.teardown
+    connection.teardown_slow
+    connection.drop_table :test_data
+  end
+  
+end

data/test/new_relic/agent/tc_active_record.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'new_relic/agent/model_fixture'
+
+
+class ActiveRecordInstrumentationTests < Test::Unit::TestCase
+  
+  def setup
+    super
+    begin
+      NewRelic::Agent::ModelFixture.setup
+    rescue => e
+      puts e
+      raise e
+    end
+    @agent = NewRelic::Agent.instance
+    @agent.start :test, :test
+    @agent.transaction_sampler.harvest_slowest_sample
+  end
+  
+  def teardown
+    @agent.shutdown
+    @agent.stats_engine.harvest_timeslice_data Hash.new, Hash.new
+    NewRelic::Agent::ModelFixture.teardown
+    super
+  end
+  
+  def test_finder
+    NewRelic::Agent::ModelFixture.create :id => 0, :name => 'jeff'
+    NewRelic::Agent::ModelFixture.find(:all)
+    s = NewRelic::Agent.get_stats("ActiveRecord/NewRelic::Agent::ModelFixture/find")
+    assert_equal 1, s.call_count
+    NewRelic::Agent::ModelFixture.find_all_by_name "jeff"
+    s = NewRelic::Agent.get_stats("ActiveRecord/NewRelic::Agent::ModelFixture/find")
+    assert_equal 2, s.call_count
+  end
+  
+  def test_run_explains
+    NewRelic::Agent::ModelFixture.find(:all)
+    sample = @agent.transaction_sampler.harvest_slowest_sample
+    segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_equal "SELECT * FROM `test_data`", segment.params[:sql].strip
+    NewRelic::TransactionSample::Segment.any_instance.expects(:explain_sql).returns([])
+    sample = sample.prepare_to_send(:obfuscate_sql => true, :explain_enabled => true, :explain_sql => 0.0)
+    segment = sample.root_segment.called_segments.first.called_segments.first
+  end
+  def test_prepare_to_send
+    NewRelic::Agent::ModelFixture.find(:all)
+    sample = @agent.transaction_sampler.harvest_slowest_sample
+    segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_match /^SELECT /, segment.params[:sql]
+    assert segment.duration > 0.0, "Segment duration must be greater than zero."
+    sample = sample.prepare_to_send(:record_sql => :raw, :explain_enabled => true, :explain_sql => 0.0)
+    segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_match /^SELECT /, segment.params[:sql]
+    explanations = segment.params[:explanation]
+    assert_not_nil explanations, "No explains in segment: #{segment}"
+    assert_equal 1, explanations.size,"No explains in segment: #{segment}" 
+    assert_equal 1, explanations.first.size
+    
+  end
+  def test_transaction
+    
+    NewRelic::Agent::ModelFixture.find(:all)
+    sample = @agent.transaction_sampler.harvest_slowest_sample
+    sample = sample.prepare_to_send(:obfuscate_sql => true, :explain_enabled => true, :explain_sql => 0.0)
+    segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_nil segment.params[:sql], "SQL should have been removed."
+    explanations = segment.params[:explanation]
+    assert_not_nil explanations, "No explains in segment: #{segment}"
+    assert_equal 1, explanations.size,"No explains in segment: #{segment}" 
+    assert_equal 1, explanations.first.size
+    
+    if isPostgres?
+      assert_equal Array, explanations.class
+      assert_equal Array, explanations[0].class
+      assert_equal Array, explanations[0][0].class
+      assert_match /Seq Scan on test_data/, explanations[0][0].join(";") 
+    else
+      assert_equal "1;SIMPLE;test_data;ALL;;;;;1;", explanations.first.first.join(";")
+    end
+    
+    s = NewRelic::Agent.get_stats("ActiveRecord/NewRelic::Agent::ModelFixture/find")
+    assert_equal 1, s.call_count
+  end
+  
+  private 
+  def isPostgres?
+    NewRelic::Agent::ModelFixture.configurations[RAILS_ENV]['adapter'] =~ /postgres/
+  end
+  
+end

data/test/new_relic/agent/tc_agent.rb

@@ -0,0 +1,112 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+##require 'new_relic/agent/agent'
+##require 'new_relic/local_environment'
+require 'net/http'
+
+class AgentTests < ActiveSupport::TestCase
+  
+  attr_reader :agent
+  
+  # Fake out the agent to think mongrel is running
+  def setup
+    @agent = NewRelic::Agent.instance
+    @agent.start :test, :test
+  end
+  
+  # Remove the port method so it won't think mongrel
+  # is available
+  def teardown
+    @agent.shutdown
+    super
+  end
+  
+  def test_public_apis
+    begin
+      NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
+        puts sql
+      end
+      fail
+    rescue
+      # ok
+    end
+    
+    
+    ignore_called = false
+    NewRelic::Agent.ignore_error_filter do |e|
+      ignore_called = true
+      nil
+    end
+    
+    NewRelic::Agent.agent.error_collector.notice_error('path', nil, {:x => 'y'}, ActionController::RoutingError.new("message"))
+    
+    assert ignore_called    
+  end
+  
+  def test_startup_shutdown
+    @agent.shutdown
+    assert (not @agent.started?)
+    @agent.start "ruby", "test1"
+    assert @agent.started?
+    @agent.shutdown
+    @agent.start "ruby", "test2"
+  end
+  def test_setup_log_default
+    assert @agent.log.instance_of?(Logger), @agent.log
+    logfile = @agent.log.instance_eval { @logdev.filename }
+    assert_match /\/log\/newrelic_agent\..*\.log$/,logfile
+    @agent.shutdown
+  end
+  
+  def test_classloading_patch
+    require 'new_relic/agent/patch_const_missing'
+    NewRelic::Agent::Agent.newrelic_set_agent_thread(Thread.current)
+    # try loading some non-existent class
+    NewRelic::Config.instance.log.expects(:warn).at_least_once.with{|args| args =~ /calling const_missing.*:FooBar/}
+    NewRelic::Config.instance.log.expects(:warn).with{|args| args =~ /calling const_missing.*:FooBaz/}.never
+    NewRelic::Agent::Agent.newrelic_enable_warning
+    assert_raise NameError do
+      FooBar::Bat
+    end
+    NewRelic::Agent::Agent.newrelic_disable_warning
+    assert_raise NameError do
+      FooBaz::Bat
+    end
+  end
+  def test_info
+    props = NewRelic::Config.instance.app_config_info
+    list = props.assoc('Plugin List').last.sort
+    assert_equal 4, (list & %w[active_merchant active_scaffold acts_as_list acts_as_state_machine ]).size, list.join("\n")
+    assert_equal 'mysql', props.assoc('Database adapter').last
+  end
+  def test_version
+    assert_match /\d\.\d\.\d+/, NewRelic::VERSION::STRING
+  end
+  
+  def test_invoke_remote__ignore_non_200_results
+    NewRelic::Agent::Agent.class_eval do
+      public :invoke_remote
+    end
+    response_mock = mock()
+    Net::HTTP.any_instance.stubs(:request).returns(response_mock)
+    response_mock.stubs(:message).returns("bogus error")
+    
+    for code in %w[500 504 400 302 503] do 
+      assert_raise NewRelic::Agent::IgnoreSilentlyException, "Ignore #{code}" do
+        response_mock.stubs(:code).returns(code)
+        NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0
+      end
+    end
+  end
+  def test_invoke_remote__throw_other_errors
+    NewRelic::Agent::Agent.class_eval do
+      public :invoke_remote
+    end
+    response_mock = Net::HTTPSuccess.new  nil, nil, nil
+    response_mock.stubs(:body).returns("")
+    Marshal.stubs(:load).raises(RuntimeError, "marshal issue")
+    Net::HTTP.any_instance.stubs(:request).returns(response_mock)
+    assert_raise RuntimeError do
+      NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0xFEFE
+    end
+  end
+end

data/test/new_relic/agent/tc_collection_helper.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'ostruct'
+require 'new_relic/agent/model_fixture'
+
+class NewRelic::Agent::CollectionHelperTests < Test::Unit::TestCase
+  
+  def setup
+    super
+    NewRelic::Agent::ModelFixture.setup
+    NewRelic::Agent.instance.start :test, :test
+  end
+  def teardown
+    NewRelic::Agent::ModelFixture.teardown
+    NewRelic::Agent.instance.shutdown
+    super
+  end
+  
+  include NewRelic::Agent::CollectionHelper
+  def test_string
+    val = ('A'..'Z').to_a.join * 100
+    assert_equal val.first(256) + "...", normalize_params(val)
+  end
+  def test_array
+    new_array = normalize_params [ 1000 ] * 50
+    assert_equal 20, new_array.size
+    assert_equal '1000', new_array[0]
+  end
+  def test_boolean
+    np = normalize_params(APP_CONFIG)
+    assert_equal false, np['disable_ui']
+  end
+  def test_coercible_string
+    s = CoercibleString.new "This is a string"
+    assert_equal "This is a string", s.to_s
+    assert_equal CoercibleString, s.class
+    assert_equal String, s.to_s.class
+    params = normalize_params(:val => [s])
+    assert_equal String, params[:val][0].class
+    assert_equal String, flatten(s).class
+    assert_equal String, truncate(s, 2).class
+  end
+  def test_number
+    np = normalize_params({ 'one' => 1.0, 'two' => '2'})
+  end
+  def test_nil
+    np = normalize_params({ nil => 1.0, 'two' => nil})
+    assert_equal "1.0", np['']
+    assert_equal nil, np['two']
+  end
+  def test_hash
+    val = ('A'..'Z').to_a.join * 100
+    assert_equal Hash["ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF..." => (("0"*256) + "...")], normalize_params({ val => '0' * 512 })
+  end
+  class MyHash < Hash
+    
+  end
+  # Test to ensure that hash subclasses are properly converted
+  def test_hash_subclass
+    h = MyHash.new
+    h[:mine] = 'mine'
+    custom_params = { :one => {:hash => { :a => :b}, :myhash => h }}
+    nh = normalize_params(custom_params)
+    myhash = custom_params[:one][:myhash]
+    assert_equal MyHash, myhash.class 
+    myhash = nh[:one][:myhash]
+    assert_equal Hash, myhash.class 
+  end
+  
+  class MyEnumerable
+     include Enumerable
+     
+     def each
+       yield "1"
+     end
+  end
+  
+  def test_enumerable
+    e = MyEnumerable.new
+    custom_params = { :one => {:hash => { :a => :b}, :myenum => e }}
+    nh = normalize_params(custom_params)
+    myenum = nh[:one][:myenum]
+    assert_equal ["1"], myenum
+  end
+  
+  
+  def test_object
+    assert_equal ["foo", '#<OpenStruct z="q">'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
+  end
+  
+  def test_strip_backtrace
+    begin
+      NewRelic::Agent::ModelFixture.find 0
+      flunk "should throw"
+    rescue => e
+      #      puts e
+      #      puts e.backtrace.join("\n")
+      #      puts "\n\n"
+      clean_trace = strip_nr_from_backtrace(e.backtrace)
+      assert_equal 0, clean_trace.grep(/newrelic_rpm/).size, clean_trace.grep(/newrelic_rpm/)
+      assert_equal 0, clean_trace.grep(/trace/).size, clean_trace.grep(/trace/)
+      assert_equal 3, clean_trace.grep(/find/).size, "should see three frames with 'find' in them: \n#{clean_trace.join("\n")}"
+    end
+  end
+end