rpm_contrib 2.1.3 → 2.1.4.beta

data/CHANGELOG

@@ -1,3 +1,10 @@
+* Version 2.1.4.beta
+
+  Updated requirements to latest agent with some bug fixes for background jobs
+  Converted instrumentation to install with DependencyDetection in the latest Agent
+  Changed Resque instrumentation from a plugin back to method chaining
+  Fixed several reported bugs related to resque
+  
 * Version 2.1.3
 
   Fixed typo in Resque instrumentation

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake'
 # See http://www.rubygems.org/read/chapter/20 
 
 def version
-  @rpm_contrib_version ||= File.read("CHANGELOG")[/Version ([\d\.]+)$/, 1]
+  @rpm_contrib_version ||= File.read("CHANGELOG")[/Version ([\d\.]+\w*)$/, 1]
 end
 
 RDOC_FILES = FileList['README*','LICENSE','CHANGELOG']
@@ -22,7 +22,7 @@ begin
     gem.email = "support@newrelic.com"
     gem.homepage = "http://github.com/newrelic/rpm_contrib"
     gem.author = "Bill Kayser"
-    gem.add_dependency 'newrelic_rpm', '>=3.0.0'
+    gem.add_dependency 'newrelic_rpm', '>=3.1.1'
     gem.version = version
     gem.files = FileList['LICENSE', 'README*', 'lib/**/*.rb', 'bin/*', '[A-Z]*', 'test/**/*'].to_a
     gem.rdoc_options <<

data/lib/rpm_contrib/detection/camping.rb

@@ -1,6 +1,6 @@
 module NewRelic #:nodoc:
   # The class defined in the
-  # newrelic_rpm[http://newrelic.github.com/rpm] which can be ammended
+  # newrelic_rpm[http://newrelic.github.com/rpm] which can be amended
   # to support new frameworks by defining modules in this namespace.
   class LocalEnvironment #:nodoc:
     module Camping

data/lib/rpm_contrib/instrumentation/active_mq.rb

@@ -2,15 +2,15 @@
 # Robert R. Meyer
 # Blue-Dog-Archolite @ GitHub
 
-module RpmContrib
-  module Instrumentation
-    module ActiveMessaging
-      if defined?(::ActiveMessaging::Processor) and not NewRelic::Control.instance['disable_active_mq']
-        ::ActiveMessaging::Processor.class_eval do
-          class << self
-            add_method_tracer :on_message, 'ActiveMessaging/OnMessage'
-          end
-        end
+DependencyDetection.defer do
+  depends_on do
+    defined?(::ActiveMessaging::Processor) && !NewRelic::Control.instance['disable_active_mq']
+  end
+
+  executes do
+    ::ActiveMessaging::Processor.class_eval do
+      class << self
+        add_method_tracer :on_message, 'ActiveMessaging/OnMessage'
       end
     end
   end

data/lib/rpm_contrib/instrumentation/aws.rb

@@ -1,6 +1,63 @@
-module RpmContrib
-  module Instrumentation
-    module Aws
+# AWS Instrumentation by Brian Doll of New Relic
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(::AWS::S3) && !NewRelic::Control.instance['disable_aws-s3']
+  end
+
+  executes do
+
+    # Instrument connections to the AWS-S3 service
+    ::AWS::S3::Connection::Management::ClassMethods.module_eval do
+      add_method_tracer :establish_connection!, 'AWS-S3/establish_connection!'
+    end
+
+    # Instrument methods on Bucket
+    ::AWS::S3::Bucket.instance_eval do
+      class << self
+        add_method_tracer :create,  'AWS-S3/Bucket/create'
+        add_method_tracer :find,    'AWS-S3/Bucket/find'
+        add_method_tracer :objects, 'AWS-S3/Bucket/objects'
+        add_method_tracer :delete,  'AWS-S3/Bucket/delete'
+        add_method_tracer :list,    'AWS-S3/Bucket/list'
+      end
+    end
+
+    # Instrument methods on Bucket instances
+    ::AWS::S3::Bucket.class_eval do
+      add_method_tracer :[],        'AWS-S3/Bucket/#{self.name}/[]'
+      add_method_tracer :new_object,'AWS-S3/Bucket/#{self.name}/new_objects'
+      add_method_tracer :objects,   'AWS-S3/Bucket/#{self.name}/objects'
+      add_method_tracer :delete,    'AWS-S3/Bucket/#{self.name}/delete'
+      add_method_tracer :delete_all,'AWS-S3/Bucket/#{self.name}/delete_all'
+      add_method_tracer :update,    'AWS-S3/Bucket/#{self.name}/update'
+    end
+
+    # Instrument methods on S3Object
+    ::AWS::S3::S3Object.instance_eval do
+      class << self
+        add_method_tracer :about,   'AWS-S3/S3Object/about'
+        add_method_tracer :copy,    'AWS-S3/S3Object/copy'
+        add_method_tracer :delete,  'AWS-S3/S3Object/delete'
+        add_method_tracer :rename,  'AWS-S3/S3Object/rename'
+        add_method_tracer :store,   'AWS-S3/S3Object/store'
+      end
+    end
+
+    # Instrument methods on S3Object instances
+    # Metric names are aggregated across all S3Objects since having a metric for
+    # every single S3Object instance and method pair would be fairly useless
+    ::AWS::S3::S3Object.class_eval do
+      add_method_tracer :value,     'AWS-S3/S3Objects/value'
+      add_method_tracer :about,     'AWS-S3/S3Objects/about'
+      add_method_tracer :metadata,  'AWS-S3/S3Objects/metadata'
+      add_method_tracer :store,     'AWS-S3/S3Objects/store'
+      add_method_tracer :delete,    'AWS-S3/S3Objects/delete'
+      add_method_tracer :copy,      'AWS-S3/S3Objects/copy'
+      add_method_tracer :rename,    'AWS-S3/S3Objects/rename'
+      add_method_tracer :etag,      'AWS-S3/S3Objects/etag'
+      add_method_tracer :owner,     'AWS-S3/S3Objects/owner'
     end
   end
 end
+

data/lib/rpm_contrib/instrumentation/camping.rb

@@ -1,5 +1,3 @@
-require 'new_relic/agent/instrumentation/controller_instrumentation'
-
 module RPMContrib
   module Instrumentation
     # == Instrumentation for Camping
@@ -20,23 +18,22 @@ module RPMContrib
     # Camping code example:
     # -------------------------------------------------------------------------------------
     #
-    #	require "newrelic_rpm"
+    #	require "rpm_contrib"
     #
     #	Camping.goes :NewRelicCampingTest
     #
     #	module NewRelicCampingTest
     #	  # your code
     #
-    #	  include NewRelic::Agent::Instrumentation::Camping
+    #	  include RPMContrib::Instrumentation::Camping
     #
     #	end
     #
     #
-
     module Camping
 
       def self.included(mod)
-
+        require 'new_relic/agent/instrumentation/controller_instrumentation'
         # Since the Camping::Base module is essentially copied
         # into the main module (the mod passed in) of a Camping app
         # using the Camping.goes :NewRelicCampingTest syntax

data/lib/rpm_contrib/instrumentation/cassandra.rb

@@ -1,29 +1,23 @@
-module RpmContrib
-  module Instrumentation
-    module Cassandra
-      # == Cassandra Instrumentation
-      #
-
-      if defined?(::Cassandra) and not  NewRelic::Control.instance['disable_cassandra_instrumentation']
-
-        ::Cassandra.class_eval do
-          add_method_tracer :insert,               'Database/Cassandra/insert'
-          add_method_tracer :remove,               'Database/Cassandra/remove'
-          add_method_tracer :clear_column_family!, 'Database/Cassandra/clear_column_family!'
-          add_method_tracer :clear_keyspace!,      'Database/Cassandra/clear_keyspace!'
-          add_method_tracer :count_columns,        'Database/Cassandra/count_columns'
-          add_method_tracer :multi_count_columns,  'Database/Cassandra/multi_count_columns'
-          add_method_tracer :get_columns,          'Database/Cassandra/get_columns'
-          add_method_tracer :multi_get_columns,    'Database/Cassandra/multi_get_columns'
-          add_method_tracer :get,                  'Database/Cassandra/get'
-          add_method_tracer :multi_get,            'Database/Cassandra/multi_get'
-          add_method_tracer :exists?,              'Database/Cassandra/exists?'
-          add_method_tracer :get_range,            'Database/Cassandra/get_range'
-          add_method_tracer :count_range,          'Database/Cassandra/count_range'
-          add_method_tracer :batch,                'Database/Cassandra/batch'
-        end
-
-      end
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Cassandra) && !NewRelic::Control.instance['disable_cassandra_instrumentation']
+  end
+  executes do
+    ::Cassandra.class_eval do
+      add_method_tracer :insert,               'Database/Cassandra/insert'
+      add_method_tracer :remove,               'Database/Cassandra/remove'
+      add_method_tracer :clear_column_family!, 'Database/Cassandra/clear_column_family!'
+      add_method_tracer :clear_keyspace!,      'Database/Cassandra/clear_keyspace!'
+      add_method_tracer :count_columns,        'Database/Cassandra/count_columns'
+      add_method_tracer :multi_count_columns,  'Database/Cassandra/multi_count_columns'
+      add_method_tracer :get_columns,          'Database/Cassandra/get_columns'
+      add_method_tracer :multi_get_columns,    'Database/Cassandra/multi_get_columns'
+      add_method_tracer :get,                  'Database/Cassandra/get'
+      add_method_tracer :multi_get,            'Database/Cassandra/multi_get'
+      add_method_tracer :exists?,              'Database/Cassandra/exists?'
+      add_method_tracer :get_range,            'Database/Cassandra/get_range'
+      add_method_tracer :count_range,          'Database/Cassandra/count_range'
+      add_method_tracer :batch,                'Database/Cassandra/batch'
     end
   end
 end

data/lib/rpm_contrib/instrumentation/crack.rb

@@ -1,25 +1,28 @@
-module RpmContrib
-  module Instrumentation
-    module Crack
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Crack::JSON) && !NewRelic::Control.instance['disable_crack']
+  end
 
-      if defined?(::Crack) && !NewRelic::Control.instance['disable_crack']
-        if defined?(::Crack::JSON)
-          ::Crack::JSON.class_eval do
-            class << self
-              include NewRelic::Agent::MethodTracer
-              add_method_tracer :parse, 'Parser/#{self.name}/parse'
-            end
-          end
-        end
+  executes do
+    ::Crack::JSON.class_eval do
+      class << self
+        include NewRelic::Agent::MethodTracer
+        add_method_tracer :parse, 'Parser/#{self.name}/parse'
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Crack::XML) && !NewRelic::Control.instance['disable_crack']
+  end
 
-        if defined?(::Crack::XML)
-          ::Crack::XML.class_eval do
-            class << self
-              include NewRelic::Agent::MethodTracer
-              add_method_tracer :parse, 'Parser/#{self.name}/parse'
-            end
-          end
-        end
+  executes do
+    ::Crack::XML.class_eval do
+      class << self
+        include NewRelic::Agent::MethodTracer
+        add_method_tracer :parse, 'Parser/#{self.name}/parse'
       end
     end
   end

data/lib/rpm_contrib/instrumentation/curb.rb

@@ -1,45 +1,47 @@
-module RpmContrib
-  module Instrumentation
-    module Curl
-      if defined?(::Curl) and not NewRelic::Control.instance['disable_curb']
-        ::Curl::Easy.class_eval do
-          def host
-            URI.parse(self.url).host
-          end
+DependencyDetection.defer do
 
-          # TODO: http, http_delete, http_get, http_post, http_head, http_put
-          def perform_with_newrelic_trace(*args, &block)
-            metrics = ["External/#{host}/Curl::Easy","External/#{host}/all"]
-            if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
-              metrics << "External/allWeb"
-            else
-              metrics << "External/allOther"
-            end
-            self.class.trace_execution_scoped metrics do
-              perform_without_newrelic_trace(*args, &block)
-            end
-          end
-          alias perform_without_newrelic_trace perform
-          alias perform perform_with_newrelic_trace
+  depends_on do
+    defined?(::Curl) and not NewRelic::Control.instance['disable_curb']
+  end
+
+  executes do
+    ::Curl::Easy.class_eval do
+      def host
+        URI.parse(self.url).host
+      end
+
+      # TODO: http, http_delete, http_get, http_post, http_head, http_put
+      def perform_with_newrelic_trace(*args, &block)
+        metrics = ["External/#{host}/Curl::Easy","External/#{host}/all"]
+        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+        self.class.trace_execution_scoped metrics do
+          perform_without_newrelic_trace(*args, &block)
         end
+      end
+      alias perform_without_newrelic_trace perform
+      alias perform perform_with_newrelic_trace
+    end
 
-        ::Curl::Multi.class_eval do
-          # TODO: http
-          def perform_with_newrelic_trace(*args, &block)
-            metrics = ["External/Curl::Multi"]
-            if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
-              metrics << "External/allWeb"
-            else
-              metrics << "External/allOther"
-            end
-            self.class.trace_execution_scoped metrics do
-              perform_without_newrelic_trace(*args, &block)
-            end
-          end
-          alias perform_without_newrelic_trace perform
-          alias perform perform_with_newrelic_trace
+    ::Curl::Multi.class_eval do
+      # TODO: http
+      def perform_with_newrelic_trace(*args, &block)
+        metrics = ["External/Curl::Multi"]
+        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+        self.class.trace_execution_scoped metrics do
+          perform_without_newrelic_trace(*args, &block)
         end
       end
+      alias perform_without_newrelic_trace perform
+      alias perform perform_with_newrelic_trace
     end
   end
 end
+

data/lib/rpm_contrib/instrumentation/elastic_search.rb

@@ -1,23 +1,19 @@
 # == Elastic Search Instrumentation
 #
+DependencyDetection.defer do
+  depends_on do
+    defined?(::ElasticSearch::Client) && !NewRelic::Control.instance['disable_elastic_search_instrumentation']
+  end
 
-module RpmContrib
-  module Instrumentation
-    module ElasticSearch
-
-      if defined?(::ElasticSearch) and not  NewRelic::Control.instance['disable_elastic_search_instrumentation']
-
-        ::ElasticSearch::Client.class_eval do
-          add_method_tracer :index,  'ActiveRecord/ElasticSearch/index'
-          add_method_tracer :get,    'ActiveRecord/ElasticSearch/get'
-          add_method_tracer :delete, 'ActiveRecord/ElasticSearch/delete'
-          add_method_tracer :search, 'ActiveRecord/ElasticSearch/search'
-          add_method_tracer :scroll, 'ActiveRecord/ElasticSearch/scroll'
-          add_method_tracer :count,  'ActiveRecord/ElasticSearch/count'
-          add_method_tracer :bulk,   'ActiveRecord/ElasticSearch/bulk'
-        end
-
-      end
+  executes do
+    ::ElasticSearch::Client.class_eval do
+      add_method_tracer :index,  'ActiveRecord/ElasticSearch/index'
+      add_method_tracer :get,    'ActiveRecord/ElasticSearch/get'
+      add_method_tracer :delete, 'ActiveRecord/ElasticSearch/delete'
+      add_method_tracer :search, 'ActiveRecord/ElasticSearch/search'
+      add_method_tracer :scroll, 'ActiveRecord/ElasticSearch/scroll'
+      add_method_tracer :count,  'ActiveRecord/ElasticSearch/count'
+      add_method_tracer :bulk,   'ActiveRecord/ElasticSearch/bulk'
     end
   end
 end

data/lib/rpm_contrib/instrumentation/mongo.rb

@@ -1,47 +1,47 @@
-module RpmContrib
-  module Instrumentation
-    module Mongo
-      # Mongo Instrumentation contributed by Alexey Palazhchenko
-
-      if defined?(::Mongo) and not NewRelic::Control.instance['disable_mongodb']
-        ::Mongo::Connection.class_eval do
-          include NewRelic::Agent::MethodTracer
-
-          def instrument_with_newrelic_trace(name, payload = {}, &blk)
-            collection = payload[:collection]
-            if collection == '$cmd'
-              f = payload[:selector].first
-              name, collection = f if f
-            end
-
-            trace_execution_scoped("Database/#{collection}/#{name}") do
-              t0 = Time.now
-              res = instrument_without_newrelic_trace(name, payload, &blk)
-              NewRelic::Agent.instance.transaction_sampler.notice_sql(payload.inspect, nil, (Time.now - t0).to_f)
-              res
-            end
-          end
-
-          alias_method :instrument_without_newrelic_trace, :instrument
-          alias_method :instrument, :instrument_with_newrelic_trace
+# Mongo Instrumentation contributed by Alexey Palazhchenko
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(::Mongo) and not NewRelic::Control.instance['disable_mongodb']
+  end
+
+  executes do
+    ::Mongo::Connection.class_eval do
+      include NewRelic::Agent::MethodTracer
+
+      def instrument_with_newrelic_trace(name, payload = {}, &blk)
+        collection = payload[:collection]
+        if collection == '$cmd'
+          f = payload[:selector].first
+          name, collection = f if f
         end
 
-        ::Mongo::Cursor.class_eval do
-          include NewRelic::Agent::MethodTracer
+        trace_execution_scoped("Database/#{collection}/#{name}") do
+          t0 = Time.now
+          res = instrument_without_newrelic_trace(name, payload, &blk)
+          NewRelic::Agent.instance.transaction_sampler.notice_sql(payload.inspect, nil, (Time.now - t0).to_f)
+          res
+        end
+      end
+
+      alias_method :instrument_without_newrelic_trace, :instrument
+      alias_method :instrument, :instrument_with_newrelic_trace
+    end
 
-          def refresh_with_newrelic_trace
-            return if send_initial_query || @cursor_id.zero? # don't double report the initial query
+    ::Mongo::Cursor.class_eval do
+      include NewRelic::Agent::MethodTracer
 
-            trace_execution_scoped("Database/#{collection.name}/refresh") do
-              refresh_without_newrelic_trace
-            end
-          end
+      def refresh_with_newrelic_trace
+        return if send_initial_query || @cursor_id.zero? # don't double report the initial query
 
-          alias_method :refresh_without_newrelic_trace, :refresh
-          alias_method :refresh, :refresh_with_newrelic_trace
-          add_method_tracer :close, 'Database/#{collection.name}/close'
+        trace_execution_scoped("Database/#{collection.name}/refresh") do
+          refresh_without_newrelic_trace
         end
       end
+      alias_method :refresh_without_newrelic_trace, :refresh
+      alias_method :refresh, :refresh_with_newrelic_trace
+      add_method_tracer :close, 'Database/#{collection.name}/close'
     end
   end
+
 end

data/lib/rpm_contrib/instrumentation/paperclip.rb

@@ -1,28 +1,23 @@
-module RpmContrib
-  module Instrumentation
-    module Paperclip
-      # Paperclip Instrumentation.
-
-      if defined?(::Paperclip) && !NewRelic::Control.instance['disable_paperclip']
-
-        ::Paperclip::Attachment.class_eval do
-          add_method_tracer :save, 'Paperclip/#{name}/save'
-          add_method_tracer :assign, 'Paperclip/#{name}/assign'
-          add_method_tracer :post_process, 'Paperclip/#{name}/post_process'
-        end
-
-        ::Paperclip::Storage::Filesystem.class_eval do
-          add_method_tracer :flush_deletes, 'Paperclip/Storage/flush_deletes'
-          add_method_tracer :flush_writes, 'Paperclip/Storage/flush_writes'
-        end
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Paperclip) && !NewRelic::Control.instance['disable_paperclip']
+  end
 
-        ::Paperclip::Storage::S3.class_eval do
-          add_method_tracer :flush_deletes, 'Paperclip/Storage/flush_deletes'
-          add_method_tracer :flush_writes, 'Paperclip/Storage/flush_writes'
-        end
+  executes do
+    ::Paperclip::Attachment.class_eval do
+      add_method_tracer :save, 'Paperclip/#{name}/save'
+      add_method_tracer :assign, 'Paperclip/#{name}/assign'
+      add_method_tracer :post_process, 'Paperclip/#{name}/post_process'
+    end
 
-      end
+    ::Paperclip::Storage::Filesystem.class_eval do
+      add_method_tracer :flush_deletes, 'Paperclip/Storage/flush_deletes'
+      add_method_tracer :flush_writes, 'Paperclip/Storage/flush_writes'
+    end
 
+    ::Paperclip::Storage::S3.class_eval do
+      add_method_tracer :flush_deletes, 'Paperclip/Storage/flush_deletes'
+      add_method_tracer :flush_writes, 'Paperclip/Storage/flush_writes'
     end
   end
 end

data/lib/rpm_contrib/instrumentation/redis.rb

@@ -1,39 +1,37 @@
-module RpmContrib
-  module Instrumentation
-    module Redis
-      # Redis instrumentation contributed by Ashley Martens of ngmoco
-      #
+# Redis instrumentation contributed by Ashley Martens of ngmoco
+#
+DependencyDetection.defer do
 
-      if defined?(::Redis) and not  NewRelic::Control.instance['disable_redis']
-
-
-        ::Redis::Client.class_eval do
-
-          include NewRelic::Agent::MethodTracer
+  depends_on do
+    defined?(::Redis) && !NewRelic::Control.instance['disable_redis']
+  end
 
-          def self.redis_call_method
-            ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command
-          end
+  executes do
+    ::Redis::Client.class_eval do
 
+      include NewRelic::Agent::MethodTracer
 
-          def raw_call_command_with_newrelic_trace *args
-            method_name = args[0].is_a?(Array) ? args[0][0] : args[0]
-            metrics = ["Database/Redis/#{method_name}",
-                       (NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction? ? 'Database/Redis/allWeb' : 'Database/Redis/allOther')]
-            self.class.trace_execution_scoped(metrics) do
-              # NewRelic::Control.instance.log.debug("Instrumenting Redis Call[#{method_name}]: #{args[0].inspect}")
-              raw_call_command_without_newrelic_trace(*args)
-            end
-          end
+      def self.redis_call_method
+        ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command
+      end
 
-          alias_method :raw_call_command_without_newrelic_trace, redis_call_method
-          alias_method redis_call_method, :raw_call_command_with_newrelic_trace
 
+      def raw_call_command_with_newrelic_trace *args
+        method_name = args[0].is_a?(Array) ? args[0][0] : args[0]
+        metrics = ["Database/Redis/#{method_name}",
+                   (NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction? ? 'Database/Redis/allWeb' : 'Database/Redis/allOther')]
+        self.class.trace_execution_scoped(metrics) do
+          # NewRelic::Control.instance.log.debug("Instrumenting Redis Call[#{method_name}]: #{args[0].inspect}")
+          raw_call_command_without_newrelic_trace(*args)
         end
+      end
 
+      alias_method :raw_call_command_without_newrelic_trace, redis_call_method
+      alias_method redis_call_method, :raw_call_command_with_newrelic_trace
 
-
-      end
     end
   end
 end
+
+
+

data/lib/rpm_contrib/instrumentation/resque.rb

@@ -1,34 +1,64 @@
-module Resque
-  module Plugins
-    module NewRelicInstrumentation
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-      def around_perform_with_monitoring(*args)
-        perform_action_with_newrelic_trace(:name => 'perform', :class_name => class_name, :category => 'OtherTransaction/ResqueJob') do
-          yield(*args)
-        end
-
-        NewRelic::Agent.shutdown
-      end
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Resque)
+  end
+  executes do
+    module Resque::Plugins
+      # The plugin definition is a no-op but left in empty for backward compatibility.
+      # We were using the plugin to install instrumentation but it required you either 
+      # extend Resque::Job or extend this module.  Using the method chaining approach
+      # means you don't have to make any modifications to your job classes.
+      module NewRelicInstrumentation; end
     end
   end
 end
 
-module RPMContrib
-  module Instrumentation
-    module Resque
-      ::Resque.before_first_fork do
-        NewRelic::Agent.manual_start(:dispatcher => :resque)
-      end
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Resque::Job) and not NewRelic::Control.instance['disable_resque']
+  end
+
+  executes do
+    # == Resque Instrumentation
+    #
+    # Installs a hook to ensure the agent starts manually when the worker
+    # starts and also adds the tracer to the process method which executes
+    # in the forked task.
 
-      ::Resque.after_fork do
-        NewRelic::Agent.after_fork(:force_reconnect => false)
+    # Resque also works in a non forking mode when fork is not supported
+    begin
+      # IronRuby/JRuby don't support `Kernel.fork` yet
+      if Kernel.respond_to?(:fork)
+        Kernel.fork{exit!}
+      else
+        raise NotImplementedError
       end
+    rescue NotImplementedError
+      $rpm_cant_fork = true
+    end
 
-      ::Resque::Job.class_eval do
-        extend ::Resque::Plugins::NewRelicInstrumentation
+    ::Resque::Job.class_eval do
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      old_perform_method = instance_method(:perform)
+      define_method(:perform) do
+        class_name = (payload_class ||self.class).name
+        perform_action_with_newrelic_trace(:name => 'perform', :class_name => class_name,
+                                           :category => 'OtherTransaction/ResqueJob') do
+          old_perform_method.bind(self).call
+        end
+        # If we aren't doing true forks, then the shutdown message would end up
+        # shutting down the agent in the parent which would cause us to stop sending
+        # data.  Data is not sent from the child.
+        NewRelic::Agent.shutdown unless $rpm_cant_fork
       end
     end
-  end
-end if defined?(::Resque) and not NewRelic::Control.instance['disable_resque']
 
+    ::Resque.before_first_fork do
+      NewRelic::Agent.manual_start(:dispatcher => :resque)
+    end
+
+    ::Resque.after_fork do
+      NewRelic::Agent.after_fork(:force_reconnect => false)
+    end
+  end
+end 

data/lib/rpm_contrib/instrumentation/sinatra.rb

@@ -1,27 +1,24 @@
-module RpmContrib
-  module Instrumentation
-    module Sinatra
-      if defined?(::Sinatra::Base) and not NewRelic::Control.instance['disable_sinatra_template']
-        module ::Sinatra
-          Base.class_eval do
-            def render_with_newrelic_trace(*args, &block)
-              engine, file = *args
-              return render_without_newrelic_trace(*args, &block) if file == "= yield"
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Sinatra::Base) and not NewRelic::Control.instance['disable_sinatra_template']
+  end
 
-              file = "Proc" if file.is_a?(Proc)
-              metrics = ["Sinatra/#{engine}/#{file}"]
+  executes do
+    ::Sinatra::Base.class_eval do
+      def render_with_newrelic_trace(*args, &block)
+        engine, file = *args
+        return render_without_newrelic_trace(*args, &block) if file == "= yield"
 
-              self.class.trace_execution_scoped metrics do
-                render_without_newrelic_trace(*args, &block)
-              end
-            end
+        file = "Proc" if file.is_a?(Proc)
+        metrics = ["Sinatra/#{engine}/#{file}"]
 
-            alias render_without_newrelic_trace render
-            alias render render_with_newrelic_trace
-          end
+        self.class.trace_execution_scoped metrics do
+          render_without_newrelic_trace(*args, &block)
         end
       end
+
+      alias render_without_newrelic_trace render
+      alias render render_with_newrelic_trace
     end
   end
 end
-

data/lib/rpm_contrib/instrumentation/typhoeus.rb

@@ -1,28 +1,28 @@
-module RpmContrib
-  module Instrumentation
-    module Typhoeus
-      if defined?(::Typhoeus) and not ::NewRelic::Control.instance['disable_typhoeus']
-        require 'uri'
-        module ::Typhoeus
-          Request.instance_eval do
-            def get_with_newrelic_trace(*args, &block)
-              uri = URI.parse(args.first)
-              metrics = ["External/#{uri.host}/Typhoeus/GET","External/#{uri.host}/all"]
-              if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
-                metrics << "External/allWeb"
-              else
-                metrics << "External/allOther"
-              end
-              self.class.trace_execution_scoped metrics do
-                get_without_newrelic_trace(*args, &block)
-              end
-            end
-            alias get_without_newrelic_trace get
-            alias get get_with_newrelic_trace
-          end
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(::Typhoeus) and not ::NewRelic::Control.instance['disable_typhoeus']
+  end
+
+  executes do
+    require 'uri'
+    ::Typhoeus::Request.instance_eval do
+      def get_with_newrelic_trace(*args, &block)
+        uri = URI.parse(args.first)
+        metrics = ["External/#{uri.host}/Typhoeus/GET","External/#{uri.host}/all"]
+        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+        self.class.trace_execution_scoped metrics do
+          get_without_newrelic_trace(*args, &block)
         end
       end
+      alias get_without_newrelic_trace get
+      alias get get_with_newrelic_trace
     end
   end
 end
 
+

data/lib/rpm_contrib/instrumentation/ultrasphinx.rb

@@ -1,18 +1,17 @@
-require 'new_relic/agent/method_tracer'
+DependencyDetection.defer do
 
-module RpmContrib
-  module Instrumentation
-    module UltraSphinx
-      if defined?(::UltraSphinx) and not ::NewRelic::Control.instance['disable_ultrasphinx']
-        module ::Ultrasphinx
-          class Search
-            include NewRelic::Agent::MethodTracer
+  depends_on do
+    defined?(::UltraSphinx) and not ::NewRelic::Control.instance['disable_ultrasphinx']
+  end
+
+  executes do
+    class  ::Ultrasphinx::Search
+      include NewRelic::Agent::MethodTracer
 
-            add_method_tracer :run
-            add_method_tracer :results
-          end
-        end
-      end
+      add_method_tracer :run
+      add_method_tracer :results
     end
   end
 end
+
+

data/lib/rpm_contrib/instrumentation/workling.rb

@@ -1,21 +1,23 @@
 # Workling instrumentation contributed by Chad Ingram of Aurora Feint
 #
-module RpmContrib
-  module Instrumentation
-    module Workling
-      if defined?(::Workling) and not ::NewRelic::Control.instance['disable_workling']
-        ::Workling::Base.class_eval do
-          include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-        end
+DependencyDetection.defer do
 
-        ::Workling::Discovery.discovered.each do |clazz|
-          (clazz.public_instance_methods - ::Workling::Base.public_instance_methods).each do |method|
-            puts "added method tracer Workling/#{clazz.name}/#{method}"
-            clazz.send(:add_method_tracer, method, "Workling/#{clazz.name}/#{method}", :category => :task)
-          end
-        end
+  depends_on do
+    defined?(::Workling) and not ::NewRelic::Control.instance['disable_workling']
+  end
+
+  executes do
+    
+    ::Workling::Base.class_eval do
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    end
+
+    ::Workling::Discovery.discovered.each do |clazz|
+      (clazz.public_instance_methods - ::Workling::Base.public_instance_methods).each do |method|
+        puts "added method tracer Workling/#{clazz.name}/#{method}"
+        clazz.send(:add_method_tracer, method, "Workling/#{clazz.name}/#{method}", :category => :task)
       end
     end
   end
-end
 
+end

data/lib/rpm_contrib/instrumentation/yajl.rb

@@ -1,15 +1,14 @@
-module RpmContrib
-  module Instrumentation
-    module Yajl
-      if defined?(::Yajl::Encoder) and not  ::NewRelic::Control.instance['disable_yajl_instrumentation']
-        ::Yajl::Encoder.class_eval do
-          class << self
-            include ::NewRelic::Agent::MethodTracer
-            add_method_tracer :parse, 'Encoder/Yajl/encode'
-          end
-        end
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Yajl::Encoder) and not ::NewRelic::Control.instance['disable_yajl_instrumentation']
+  end
+
+  executes do
+    ::Yajl::Encoder.class_eval do
+      class << self
+        include ::NewRelic::Agent::MethodTracer
+        add_method_tracer :parse, 'Encoder/Yajl/encode'
       end
     end
   end
 end
-

data/lib/rpm_contrib/instrumentation.rb

@@ -1,22 +1,16 @@
-require 'rpm_contrib/instrumentation/active_mq'
-require 'rpm_contrib/instrumentation/aws'
-require 'rpm_contrib/instrumentation/camping'
-require 'rpm_contrib/instrumentation/cassandra'
-require 'rpm_contrib/instrumentation/crack'
-require 'rpm_contrib/instrumentation/curb'
-require 'rpm_contrib/instrumentation/elastic_search'
-require 'rpm_contrib/instrumentation/mongo'
-require 'rpm_contrib/instrumentation/paperclip'
-require 'rpm_contrib/instrumentation/redis'
-require 'rpm_contrib/instrumentation/resque'
-require 'rpm_contrib/instrumentation/sinatra'
-require 'rpm_contrib/instrumentation/typhoeus'
-require 'rpm_contrib/instrumentation/ultrasphinx'
-require 'rpm_contrib/instrumentation/workling'
-require 'rpm_contrib/instrumentation/yajl'
-
-
+require 'newrelic_rpm'
 module RpmContrib
+  # Contributed instrumentation files for use with newrelic_rpm gem
   module Instrumentation
   end
 end
+
+pattern = File.expand_path "../instrumentation/**/*.rb",  __FILE__
+Dir.glob pattern do |file|
+  begin
+    require file.to_s
+  rescue Exception => e
+    NewRelic::Agent.logger.error "Skipping instrumentation file '#{file}': #{e}"
+    NewRelic::Agent.logger.debug e.backtrace.join("\n")
+  end
+end

data/lib/rpm_contrib/samplers.rb

@@ -0,0 +1,17 @@
+module RpmContrib
+  # Samplers are subclasses of NewRelic::Agent::Sampler which periodically collect metric data in a 
+  # background thread.  Sampler classes belong in the sampler subdirectory and must be loaded before
+  # the agent starts.
+  module Samplers
+  end
+end
+
+pattern = File.expand_path "../samplers/**/*.rb",  __FILE__
+Dir.glob pattern do |file|
+  begin
+    require file.to_s
+  rescue Exception => e
+    NewRelic::Agent.logger.error "Skipping instrumentation file '#{file}': #{e}"
+    NewRelic::Agent.logger.debug e.backtrace.join("\n")
+  end
+end

data/lib/rpm_contrib.rb

@@ -1,39 +1,40 @@
 RPM_CONTRIB_LIB = File.dirname(__FILE__)
 
-module RPMContrib
-  VERSION = File.read(RPM_CONTRIB_LIB+"/../CHANGELOG")[/Version ([\d\.]+)$/, 1]
+module RPMContrib; end
 
-  def self.init_sequence
-    Proc.new do
-      # Tell the agent to load all the files in the
-      # rpm_contrib/instrumentation directory.
-      NewRelic::Agent.add_instrumentation(RPM_CONTRIB_LIB+"/rpm_contrib/instrumentation/**/*.rb")
-
-      # Load all the Sampler class definitions.  These will register
-      # automatically with the agent.
-      Dir.glob(RPM_CONTRIB_LIB + "/rpm_contrib/samplers/**/*.rb") { |file| require file }
-    end
-  end
-
-end
 # Perform any framework/dispatcher detection before loading the rpm gem.
 require 'rpm_contrib/detection'
-puts "Warning! The rpm_contrib gem should be loaded before the newrelic_rpm gem if you are using Resque or Camping." if defined?(::NewRelic) && defined?(::NewRelic::Control)
+if defined?(::NewRelic) && defined?(::NewRelic::Control)
+  puts "Warning! The rpm_contrib gem should be loaded before the newrelic_rpm gem if you are using Resque or Camping." 
+end
+
 require 'newrelic_rpm'
+require 'rpm_contrib/instrumentation'
+
+# Load all the Sampler class definitions.  These will register
+# automatically with the agent.
+require 'rpm_contrib/samplers'
+
 if defined? Rails
   # Rails 3.x+
   if Rails.respond_to?(:version) && Rails.version =~ /^3/
     module NewRelic
       class Railtie < Rails::Railtie
-        initializer("rpm_contrib.start_plugin", &RPMContrib.init_sequence)
+        initializer("rpm_contrib.start_plugin"){ NewRelic::Control.instance.init_plugin }
       end
     end
   # Rails 2.x
   elsif defined?(Rails) && Rails.respond_to?(:configuration)
-    Rails.configuration.after_initialize &RPMContrib.init_sequence
+    
+    Rails.configuration.after_initialize { NewRelic::Control.instance.init_plugin }
   else
     raise "The rpm_contrib gem supports Rails 2.2+ only."
   end
 else
-  RPMContrib.init_sequence.call
+  # If not running Rails, it is important that you load the contrib gem as late 
+  # as possible so the agent initializes after everything else.  Either that 
+  # or make the following call yourself at the end of your startup sequence
+  # (it is idempotent).
+  NewRelic::Control.instance.init_plugin 
 end
+

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rpm_contrib
 version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: 
+  hash: 31098233
+  prerelease: 6
   segments: 
   - 2
   - 1
-  - 3
-  version: 2.1.3
+  - 4
+  - beta
+  version: 2.1.4.beta
 platform: ruby
 authors: 
 - Bill Kayser
@@ -15,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-14 00:00:00 -07:00
+date: 2011-08-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +27,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 1
         segments: 
         - 3
-        - 0
-        - 0
-        version: 3.0.0
+        - 1
+        - 1
+        version: 3.1.1
   type: :runtime
   version_requirements: *id001
 description: |
@@ -60,7 +61,6 @@ files:
 - lib/rpm_contrib/instrumentation.rb
 - lib/rpm_contrib/instrumentation/active_mq.rb
 - lib/rpm_contrib/instrumentation/aws.rb
-- lib/rpm_contrib/instrumentation/aws/s3.rb
 - lib/rpm_contrib/instrumentation/camping.rb
 - lib/rpm_contrib/instrumentation/cassandra.rb
 - lib/rpm_contrib/instrumentation/crack.rb
@@ -75,6 +75,7 @@ files:
 - lib/rpm_contrib/instrumentation/ultrasphinx.rb
 - lib/rpm_contrib/instrumentation/workling.rb
 - lib/rpm_contrib/instrumentation/yajl.rb
+- lib/rpm_contrib/samplers.rb
 - test/helper.rb
 - test/schema.rb
 - test/test_curb.rb
@@ -106,22 +107,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Contributed Instrumentation for New Relic RPM
-test_files: 
-- test/helper.rb
-- test/schema.rb
-- test/test_curb.rb
-- test/test_redis.rb
-- test/test_workling.rb
+test_files: []
+

data/lib/rpm_contrib/instrumentation/aws/s3.rb

@@ -1,64 +0,0 @@
-module RpmContrib
-  module Instrumentation
-    module Aws
-      module S3
-        # Instrumentation for the AWS-S3 gem for New Relic RPM by Brian Doll
-        if defined?(::AWS::S3) && !NewRelic::Control.instance['disable_aws-s3']
-
-          # Instrument connections to the AWS-S3 service
-          ::AWS::S3::Connection::Management::ClassMethods.module_eval do
-            add_method_tracer :establish_connection!, 'AWS-S3/establish_connection!'
-          end
-
-          # Instrument methods on Bucket
-          ::AWS::S3::Bucket.instance_eval do
-            class << self
-              add_method_tracer :create,  'AWS-S3/Bucket/create'
-              add_method_tracer :find,    'AWS-S3/Bucket/find'
-              add_method_tracer :objects, 'AWS-S3/Bucket/objects'
-              add_method_tracer :delete,  'AWS-S3/Bucket/delete'
-              add_method_tracer :list,    'AWS-S3/Bucket/list'
-            end
-          end
-
-          # Instrument methods on Bucket instances
-          ::AWS::S3::Bucket.class_eval do
-            add_method_tracer :[],        'AWS-S3/Bucket/#{self.name}/[]'
-            add_method_tracer :new_object,'AWS-S3/Bucket/#{self.name}/new_objects'
-            add_method_tracer :objects,   'AWS-S3/Bucket/#{self.name}/objects'
-            add_method_tracer :delete,    'AWS-S3/Bucket/#{self.name}/delete'
-            add_method_tracer :delete_all,'AWS-S3/Bucket/#{self.name}/delete_all'
-            add_method_tracer :update,    'AWS-S3/Bucket/#{self.name}/update'
-          end
-
-          # Instrument methods on S3Object
-          ::AWS::S3::S3Object.instance_eval do
-            class << self
-              add_method_tracer :about,   'AWS-S3/S3Object/about'
-              add_method_tracer :copy,    'AWS-S3/S3Object/copy'
-              add_method_tracer :delete,  'AWS-S3/S3Object/delete'
-              add_method_tracer :rename,  'AWS-S3/S3Object/rename'
-              add_method_tracer :store,   'AWS-S3/S3Object/store'
-            end
-          end
-
-          # Instrument methods on S3Object instances
-          # Metric names are aggregated across all S3Objects since having a metric for
-          # every single S3Object instance and method pair would be fairly useless
-          ::AWS::S3::S3Object.class_eval do
-            add_method_tracer :value,     'AWS-S3/S3Objects/value'
-            add_method_tracer :about,     'AWS-S3/S3Objects/about'
-            add_method_tracer :metadata,  'AWS-S3/S3Objects/metadata'
-            add_method_tracer :store,     'AWS-S3/S3Objects/store'
-            add_method_tracer :delete,    'AWS-S3/S3Objects/delete'
-            add_method_tracer :copy,      'AWS-S3/S3Objects/copy'
-            add_method_tracer :rename,    'AWS-S3/S3Objects/rename'
-            add_method_tracer :etag,      'AWS-S3/S3Objects/etag'
-            add_method_tracer :owner,     'AWS-S3/S3Objects/owner'
-          end
-          
-        end
-      end
-    end
-  end
-end