wireframe-rpm_contrib 1.0.12.7 → 2.1.6.1

data/lib/rpm_contrib/instrumentation/aws.rb

@@ -0,0 +1,68 @@
+# AWS Instrumentation by Brian Doll of New Relic
+DependencyDetection.defer do
+  @name = :aws
+  
+  depends_on do
+    defined?(::AWS::S3) && !NewRelic::Control.instance['disable_aws-s3']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing AWS instrumentation'
+  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,34 +18,33 @@ 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 
+        # into the main module (the mod passed in) of a Camping app
         # using the Camping.goes :NewRelicCampingTest syntax
         # we need to evaluate "weld" the NewRelic plugin in the context of the new Base
-        
+
         (Kernel.const_get(mod.name)::Base).module_eval do
           include NewRelic::Agent::Instrumentation::ControllerInstrumentation
           add_transaction_tracer :service
         end
       end
-      
+
     end	#RPMContrib::Instrumentation::Camping
   end
 end

data/lib/rpm_contrib/instrumentation/cassandra.rb

@@ -1,23 +1,30 @@
-# == Cassandra Instrumentation
-#
-
-if defined?(::Cassandra) and not  NewRelic::Control.instance['disable_cassandra_instrumentation']
+DependencyDetection.defer do
+  @name = :cassandra
+  
+  depends_on do
+    defined?(::Cassandra) && !NewRelic::Control.instance['disable_cassandra_instrumentation']
+  end
   
-  ::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'
+  executes do
+    NewRelic::Agent.logger.debug 'Installing 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

@@ -0,0 +1,41 @@
+DependencyDetection.defer do
+  @name = :crack_json
+
+  depends_on do
+    defined?(::Crack::JSON) && !NewRelic::Control.instance['disable_crack']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Crack::JSON instrumentation'
+  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
+  @name = :crack_xml
+  
+  depends_on do
+    defined?(::Crack::XML) && !NewRelic::Control.instance['disable_crack']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Crack::XML instrumentation'
+  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
+end

data/lib/rpm_contrib/instrumentation/curb.rb

@@ -0,0 +1,52 @@
+DependencyDetection.defer do
+  @name = :curb
+  
+  depends_on do
+    defined?(::Curl) and not NewRelic::Control.instance['disable_curb']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Curb instrumentation'
+  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
+    end
+  end
+end
+

data/lib/rpm_contrib/instrumentation/elastic_search.rb

@@ -0,0 +1,26 @@
+# == Elastic Search Instrumentation
+#
+DependencyDetection.defer do
+  @name = :elastic_search
+  
+  depends_on do
+    defined?(::ElasticSearch::Client) && !NewRelic::Control.instance['disable_elastic_search_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Elastic Search instrumentation'
+  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/kyototycoon.rb

@@ -0,0 +1,28 @@
+# KyotoTycoon instrumentation
+
+DependencyDetection.defer do
+  @name = :kyototycoon
+
+  depends_on do
+    defined?(::KyotoTycoon) && !NewRelic::Control.instance['disable_kyototycoon']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing KyotoTycoon instrumentation'
+  end
+
+  executes do
+    ::KyotoTycoon.class_eval do
+      require 'new_relic/agent/method_tracer'
+      include NewRelic::Agent::MethodTracer
+
+      [:get, :remove, :set, :add, :replace,
+       :append, :cas, :increment, :decrement, :increment_double,
+       :set_bulk, :get_bulk, :remove_bulk, :clear, :vacuum,
+       :sync, :report, :status, :match_prefix, :match_regex,
+       :keys].each do |method|
+        add_method_tracer method
+      end
+    end
+  end
+end

data/lib/rpm_contrib/instrumentation/mongo.rb

@@ -0,0 +1,54 @@
+# Mongo Instrumentation contributed by Alexey Palazhchenko
+DependencyDetection.defer do
+  @name = :mongodb
+  
+  depends_on do
+    defined?(::Mongo) and not NewRelic::Control.instance['disable_mongodb']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing MongoDB instrumentation'
+  end  
+
+  executes do
+    ::Mongo::Logging.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
+    end
+    class Mongo::Collection; include Mongo::Logging; end
+    class Mongo::Connection; include Mongo::Logging; end
+    class Mongo::Cursor; include Mongo::Logging; end
+
+    # cursor refresh is not currently instrumented in mongo driver, so not picked up by above - have to add our own here
+    ::Mongo::Cursor.class_eval do
+      include NewRelic::Agent::MethodTracer
+
+      def send_get_more_with_newrelic_trace
+        trace_execution_scoped("Database/#{collection.name}/refresh") do
+          send_get_more_without_newrelic_trace
+        end
+      end
+      alias_method :send_get_more_without_newrelic_trace, :send_get_more
+      alias_method :send_get_more, :send_get_more_with_newrelic_trace
+      add_method_tracer :close, 'Database/#{collection.name}/close'
+    end
+  end
+
+end

data/lib/rpm_contrib/instrumentation/mongoid.rb

@@ -1,53 +1,21 @@
-if defined?(::Mongoid) && !NewRelic::Control.instance['disable_mongodb']
+DependencyDetection.defer do
+  @name = :mongoid
 
-  module Mongoid #:nodoc:
-    module Document
-
-      #adding call to super
-      class << self
-        alias :old_included :included
-
-        def included(model)
-          old_included(model)
-          super
-        end
-      end
-    end
+  depends_on do
+    defined?(::Mongoid) and not NewRelic::Control.instance['disable_mongoid']
   end
 
-  module RPMContrib::Instrumentation
-
-    module Mongoid
-      def included(model)
-        model.metaclass.class_eval do
-          puts "adding mongoid method tracers for #{model.name}"
-          add_method_tracer :create, 'Database/#{self.name}/create'
-          add_method_tracer :create!, 'Database/#{self.name}/create!'
-          add_method_tracer :delete_all, 'Database/#{self.name}/delete_all'
-          add_method_tracer :destroy_all, 'Database/#{self.name}/destroy_all'
-          add_method_tracer :all, 'Database/#{self.name}/all'
-          add_method_tracer :find, 'Database/#{self.name}/find'
-          add_method_tracer :first, 'Database/#{self.name}/first'
-          add_method_tracer :last, 'Database/#{self.name}/last'
-          add_method_tracer :find_or_create_by, 'Database/#{self.name}/find_or_create_by'
-          add_method_tracer :find_or_initialize_by, 'Database/#{self.name}/find_or_initialize_by'
-          add_method_tracer :min, 'Database/#{self.name}/min'
-          add_method_tracer :max, 'Database/#{self.name}/max'
-          add_method_tracer :sum, 'Database/#{self.name}/sum'
-        end
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Mongoid instrumentation'
+  end
 
-        model.class_eval do
-          add_method_tracer :update_attributes, 'Database/#{self.class.name}/update_attributes'
-          add_method_tracer :update_attributes!, 'Database/#{self.class.name}/update_attributes!'
-          add_method_tracer :save, 'Database/#{self.class.name}/save'
-          add_method_tracer :save!, 'Database/#{self.class.name}/save!'
-          add_method_tracer :delete, 'Database/#{self.class.name}/delete'
-          add_method_tracer :destroy, 'Database/#{self.class.name}/destroy'
+  executes do
+    Mongoid::Collection.class_eval do
+      include NewRelic::Agent::MethodTracer
 
-        end
-        super
+      (Mongoid::Collections::Operations::ALL - [:<<, :[]]).each do |method|
+        add_method_tracer method, "ActiveRecord/\#{@klass}/#{method}"
       end
     end
-    ::Mongoid::Document.extend(RPMContrib::Instrumentation::Mongoid)
   end
 end

data/lib/rpm_contrib/instrumentation/paperclip.rb

@@ -1,22 +1,29 @@
-# 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'                            
+DependencyDetection.defer do
+  @name = :paperclip
+  
+  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'                            
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Paperclip instrumentation'
   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
+
+    ::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
-