newrelic_rpm 3.1.1 → 3.1.2.beta1

data/CHANGELOG

@@ -1,3 +1,9 @@
+v3.1.2
+  * Fixed some thread safety issues
+  * Work around for Ruby 1.8.7 Marshal crash bug
+  * Numerous community patches (Gabriel Horner, Bradley Harris, Diego Garcia, 
+    Tommy Sullivan, Greg Hazel, John Thomas Marino, Paul Elliott, Pan Thomakos)
+
 v3.1.1
   * Support for Rails 3.1 (thanks to Ben Hoskings via github)
   * Support for Rubinius

data/lib/new_relic/agent/agent.rb

@@ -402,16 +402,6 @@ module NewRelic
             NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
           end
 
-          # Are we in boss mode, using rubinius?
-          def using_rubinius?
-            RUBY_VERSION =~ /rubinius/i
-          end
-
-          # Is this really a world-within-a-world, running JRuby?
-          def using_jruby?
-            defined?(JRuby)
-          end
-
           # If we're using sinatra, old versions run in an at_exit
           # block so we should probably know that
           def using_sinatra?
@@ -421,7 +411,9 @@ module NewRelic
           # we should not set an at_exit block if people are using
           # these as they don't do standard at_exit behavior per MRI/YARV
           def weird_ruby?
-            using_rubinius? || using_jruby? || using_sinatra?
+            NewRelic::LanguageSupport.using_rubinius? ||
+              NewRelic::LanguageSupport.using_jruby? ||
+              using_sinatra?
           end
 
           # Installs our exit handler, which exploits the weird

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

@@ -1,6 +1,6 @@
 DependencyDetection.defer do
   depends_on do
-    defined?(ActiveMerchant)
+    defined?(ActiveMerchant) && defined?(ActiveMerchant::Billing)
   end
   
   executes do

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

@@ -6,7 +6,8 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Job)
+    defined?(::Delayed) && defined?(::Delayed::Job) &&
+      Delayed::Job.respond_to?(:invoke_job)
   end
   
   executes do
@@ -16,7 +17,7 @@ DependencyDetection.defer do
   executes do
     Delayed::Job.class_eval do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      if self.instance_methods.include?('name')
+      if self.instance_methods.include?('name') || self.instance_methods.include?(:name)
         add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob', :path => '#{self.name}'
       else
         add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob'

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

@@ -10,7 +10,7 @@ DependencyDetection.defer do
   executes do
     Net::HTTP.class_eval do
       def request_with_newrelic_trace(*args, &block)
-        metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}","External/#{@address}/all"]
+        metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}", "External/#{@address}/all", "External/all"]
         if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
           metrics << "External/allWeb"
         else

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

@@ -17,6 +17,7 @@ module NewRelic
 
           # Capture db config if we are going to try to get the explain plans
           if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
+              (defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && self.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)) ||
               (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
             supported_config = @config
           end

data/lib/new_relic/agent/instrumentation/rails3/active_record_instrumentation.rb

@@ -21,6 +21,7 @@ module NewRelic
 
           # Capture db config if we are going to try to get the explain plans
           if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
+              (defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && self.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)) ||
               (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
             supported_config = @config
           end

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

@@ -22,7 +22,7 @@ module NewRelic
             end
           elsif platform =~ /darwin9/ # 10.5
             @sampler = ShellPS.new("ps -o rsz")
-          elsif platform =~ /darwin10/ # 10.6
+          elsif platform =~ /darwin1[01]/ # 10.6 & 10.7
             @sampler = ShellPS.new("ps -o rss")
           elsif platform =~ /freebsd/
             @sampler = ShellPS.new("ps -o rss")

data/lib/new_relic/agent/shim_agent.rb

@@ -16,11 +16,11 @@ module NewRelic
       end
       def after_fork *args; end
       def start *args; end
-      def shutdown; end
+      def shutdown *args; end
       def serialize; end
-      def merge_data_from(*args); end
-      def push_trace_execution_flag(*args); end
-      def pop_trace_execution_flag(*args); end
+      def merge_data_from *args; end
+      def push_trace_execution_flag *args; end
+      def pop_trace_execution_flag *args; end
       def browser_timing_header; "" end
       def browser_timing_footer; "" end
     end

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -1,3 +1,6 @@
+require 'sync'
+require 'new_relic/language_support'
+
 module NewRelic
   module Agent
     class StatsEngine
@@ -5,40 +8,24 @@ module NewRelic
       module MetricStats
         # A simple mutex-synchronized hash to make sure our statistics
         # are internally consistent even in truly-threaded rubies like JRuby
-        class SynchronizedHash < Hash
-          def initialize(*args)
-            @mutex = Mutex.new
-            super
-          end
-
+        class SynchronizedHash < ::Hash
+          include NewRelic::LanguageSupport::SynchronizedHash
+          include Sync_m
+          
           def []=(*args)
-            @mutex.synchronize {
-              super
-            }
-          end
-
-          def [](*args)
-            @mutex.synchronize {
-              super
-            }
+            sync_synchronize { super }
           end
 
           def clear(*args)
-            @mutex.synchronize {
-              super
-            }
+            sync_synchronize { super }
           end
 
           def delete(*args)
-            @mutex.synchronize {
-              super
-            }
+            sync_synchronize { super }
           end
 
           def delete_if(*args)
-            @mutex.synchronize {
-              super
-            }
+            sync_synchronize { super }
           end
         end
         

data/lib/new_relic/control/frameworks/rails.rb

@@ -86,13 +86,18 @@ module NewRelic
         end
 
         def log!(msg, level=:info)
-          super unless should_log?
-          logger.send(level, msg)
+          if should_log?
+            logger = ::Rails.respond_to?(:logger) ? Rails.logger : ::RAILS_DEFAULT_LOGGER
+            logger.send(level, msg)
+          else
+            super
+          end
         rescue Exception => e
           super
         end
 
         def to_stdout(message)
+          logger = ::Rails.respond_to?(:logger) ? Rails.logger : ::RAILS_DEFAULT_LOGGER
           logger.info(message)
         rescue Exception => e
           super

data/lib/new_relic/control/frameworks/rails3.rb

@@ -32,8 +32,11 @@ module NewRelic
 
 
         def log!(msg, level=:info)
-          super unless should_log?
-          logger.send(level, msg)
+          if should_log?
+            logger.send(level, msg)
+          else
+            super
+          end
         rescue Exception => e
           super
         end

data/lib/new_relic/control/instance_methods.rb

@@ -1,5 +1,9 @@
+require 'new_relic/language_support'
+
 module NewRelic
   class Control
+    include NewRelic::LanguageSupport::Control
+
     # Contains methods that relate to the runtime usage of the control
     # object. Note that these are subject to override in the
     # NewRelic::Control::Framework classes that are actually instantiated
@@ -147,8 +151,7 @@ module NewRelic
           puts "Cannot find or read #{newrelic_file}"
           @yaml = {}
         else
-          YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)
-          @yaml = YAML.load(ERB.new(File.read(newrelic_file)).result(binding))
+          @yaml = load_newrelic_yml(newrelic_file, binding)
         end
       rescue ScriptError, StandardError => e
         puts e
@@ -156,6 +159,10 @@ module NewRelic
         raise "Error reading newrelic.yml file: #{e}"
       end
       
+      def load_newrelic_yml(path, binding)
+        YAML.load(ERB.new(File.read(path)).result(binding))
+      end
+      
       def root
         '.'
       end

data/lib/new_relic/data_serialization.rb

@@ -1,15 +1,20 @@
 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
-      # semaphore file is too old. If so, we should send the data
+      # 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? || semaphore_too_old?
+        NewRelic::Control.instance.disable_serialization? || store_too_large? ||
+          store_too_old? || pid_too_old?
       rescue Exception => e
         NewRelic::Control.instance.disable_serialization = true
         NewRelic::Control.instance.log.warn("Disabling serialization: #{e.message}")
@@ -32,40 +37,32 @@ module NewRelic
       # touches the age file that determines whether we should send
       # data now or not
       def update_last_sent!
-        FileUtils.touch(semaphore_path)
-      rescue Errno::ENOENT => e
-        NewRelic::Control.instance.log.warn(e.message)
+        FileUtils.touch(pid_file_path)
       end
       
-      private
-
-      def store_too_large?
-        size = File.size(file_path) > max_size
-        NewRelic::Control.instance.log.debug("Store was oversize, sending data") if size
-        size
-      rescue Errno::ENOENT
-        FileUtils.touch(file_path)
-        retry
+      def pid_too_old?
+        create_pid_file 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?
+        FileUtils.touch(file_path) 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
-      rescue Errno::ENOENT
-        FileUtils.touch(file_path)
-        retry
-      end
-
-      def semaphore_too_old?
-        age = (Time.now.to_i - File.mtime(semaphore_path).to_i)
-        NewRelic::Control.instance.log.debug("Pid was #{age} seconds old, sending data") if age > 60
-        age > 60
-      rescue Errno::ENOENT
-        FileUtils.touch(semaphore_path)
-        retry
+      end      
+    
+      def store_too_large?
+        FileUtils.touch(file_path) 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}]
@@ -122,11 +119,11 @@ module NewRelic
       end
 
       def dump(object)
-        Marshal.dump(object)
+        Marshal.dump(object.clone)
       end
-
+      
       def load(dump)
-        if dump.size == 0
+        if dump.respond_to?(:size) && dump.size == 0
           NewRelic::Control.instance.log.debug("Spool file empty.")
           return nil
         end
@@ -141,13 +138,17 @@ module NewRelic
         FileUtils.touch(file_path)
         File.truncate(file_path, 0)
       end
-
+      
+      def create_pid_file
+        File.open(pid_file_path, 'w') {|f| f.write $$ }
+      end
+      
       def file_path
         "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.db"
       end
 
-      def semaphore_path
-        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.age"
+      def pid_file_path
+        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.pid"
       end
     end
     extend ClassMethods

data/lib/new_relic/language_support.rb

@@ -0,0 +1,66 @@
+module NewRelic::LanguageSupport
+  extend self
+  
+  module DataSerialization
+    def self.included(base)
+      # need to disable GC during marshal load in 1.8.7
+      if ::RUBY_VERSION == '1.8.7' &&
+          !NewRelic::LanguageSupport.using_jruby? &&
+          !NewRelic::LanguageSupport.using_rubinius?
+        base.class_eval do
+          def self.load(*args)
+            if defined?(::GC) && ::GC.respond_to?(:disable)
+              ::GC.disable
+              val = super
+              ::GC.enable
+              val
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  module Control
+    def self.included(base)
+      # need to use syck rather than psych when possible
+      if defined?(::YAML::ENGINE)
+        base.class_eval do
+          def load_newrelic_yml(*args)
+            yamler = ::YAML::ENGINE.yamler
+            ::YAML::ENGINE.yamler = 'syck'
+            val = super
+            ::YAML::ENGINE.yamler = yamler
+            val
+          end
+        end
+      end
+    end
+  end
+  
+  module SynchronizedHash
+    def self.included(base)
+      # need to lock iteration of stats hash in 1.9.x
+      if ::RUBY_VERSION.split('.')[0,2] == ['1','9'] ||
+          NewRelic::LanguageSupport.using_jruby?
+        base.class_eval do
+          def each(*args, &block)
+            sync_synchronize(:SH) { super }
+          end
+        end
+      end
+    end
+  end
+
+  # Are we in boss mode, using rubinius?
+  def using_rubinius?
+    defined?(::RUBY_ENGINE) && ::RUBY_ENGINE == 'rbx'
+  end
+
+  # Is this really a world-within-a-world, running JRuby?
+  def using_jruby?
+    defined?(::RUBY_ENGINE) && ::RUBY_ENGINE == 'jruby'
+  end
+end

data/lib/new_relic/transaction_sample.rb

@@ -268,19 +268,21 @@ module NewRelic
 
         target_segment.add_called_segment target_called_segment
         source_called_segment.params.each do |k,v|
-        case k
+          case k
           when :backtrace
             target_called_segment[k]=v if options[:keep_backtraces]
           when :sql
             # run an EXPLAIN on this sql if specified.
-            if options[:record_sql] && options[:record_sql] && options[:explain_sql] && source_called_segment.duration > options[:explain_sql].to_f
-              target_called_segment[:explanation] = source_called_segment.explain_sql
+            if options[:record_sql] && options[:record_sql] &&
+                options[:explain_sql] &&
+                source_called_segment.duration > options[:explain_sql].to_f
+              target_called_segment[:explain_plan] = source_called_segment.explain_sql
             end
-
+            
             target_called_segment[:sql] = case options[:record_sql]
-              when :raw then v
-              when :obfuscated then TransactionSample.obfuscate_sql(v)
-              else raise "Invalid value for record_sql: #{options[:record_sql]}"
+            when :raw then v
+            when :obfuscated then TransactionSample.obfuscate_sql(v)
+            else raise "Invalid value for record_sql: #{options[:record_sql]}"
             end if options[:record_sql]
           when :connection_config
             # don't copy it