seanwalbran-rpm_contrib 2.1.6.1

data/lib/rpm_contrib/instrumentation/camping.rb

@@ -0,0 +1,50 @@
+module RPMContrib
+  module Instrumentation
+    # == Instrumentation for Camping
+    # To instrument all controllers do the following:
+    # 1. Add require 'rpm_contrib' after loading camping.
+    # 2. Add an include at the end of your main Camping app module
+    # 3. Run the following command to get the NewRelic license key to use: heroku config -all
+    # 4. Create a newrelic.yml under the /config folder with the following content:
+    #
+    #	 common: &default_settings
+    #       license_key: 'PASTE THE VALUE OF NEW_RELIC_LICENSE_KEY HERE'
+    #	    app_name: PASTE THE NAME OF YOUR CAMPING APP HERE
+    #	    monitor_mode: true
+    #
+    #	 production:
+    #       <<: *default_settings
+    #
+    # Camping code example:
+    # -------------------------------------------------------------------------------------
+    #
+    #	require "rpm_contrib"
+    #
+    #	Camping.goes :NewRelicCampingTest
+    #
+    #	module NewRelicCampingTest
+    #	  # your code
+    #
+    #	  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
+        # 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

@@ -0,0 +1,30 @@
+DependencyDetection.defer do
+  @name = :cassandra
+  
+  depends_on do
+    defined?(::Cassandra) && !NewRelic::Control.instance['disable_cassandra_instrumentation']
+  end
+  
+  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,50 @@
+# 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::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
+    end
+
+    ::Mongo::Cursor.class_eval do
+      include NewRelic::Agent::MethodTracer
+
+      def refresh_with_newrelic_trace
+        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

@@ -0,0 +1,29 @@
+DependencyDetection.defer do
+  @name = :paperclip
+  
+  depends_on do
+    defined?(::Paperclip) && !NewRelic::Control.instance['disable_paperclip']
+  end
+  
+  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

data/lib/rpm_contrib/instrumentation/picky.rb

@@ -0,0 +1,41 @@
+if defined?(::Picky)
+
+  class Picky::NewRelic
+    def self.obfuscate_tokens tokens
+      tokens.map { |t|
+        o = 'xxx'
+        o += '~' if t.similar?
+        o += '*' if t.partial?
+        o = t.qualifiers.sort.join(',') + ':' + o if t.qualifiers && t.qualifiers.respond_to?(:join)
+        o
+      }.sort.join(' ')
+    end
+  end
+
+end
+
+DependencyDetection.defer do
+  @name = :picky
+
+  depends_on do
+    defined?(::Picky) && !NewRelic::Control.instance['disable_picky']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Picky instrumentation'
+  end
+
+  executes do
+    ::Picky::Search.class_eval do
+      include NewRelic::Agent::MethodTracer
+
+      def execute_with_newrelic_trace *args
+        metrics = "Custom/Picky/search: #{Picky::NewRelic.obfuscate_tokens args[0]}"
+        self.class.trace_execution_scoped(metrics){ execute_without_newrelic_trace(*args) }
+      end
+
+      alias_method :execute_without_newrelic_trace, :execute
+      alias_method :execute, :execute_with_newrelic_trace
+    end
+  end
+end

data/lib/rpm_contrib/instrumentation/redis.rb

@@ -0,0 +1,42 @@
+# Redis instrumentation contributed by Ashley Martens of ngmoco
+#
+DependencyDetection.defer do
+  @name = :redis
+
+  depends_on do
+    defined?(::Redis) && !NewRelic::Control.instance['disable_redis']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Redis instrumentation'
+  end
+
+  executes do
+    ::Redis::Client.class_eval do
+
+      include NewRelic::Agent::MethodTracer
+
+      def self.redis_call_method
+        ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command
+      end
+
+
+      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
+
+
+

data/lib/rpm_contrib/instrumentation/resque.rb

@@ -0,0 +1,83 @@
+require 'rpm_contrib/language_support'
+
+# call this now so it is memoized before potentially forking worker processes
+RPMContrib::LanguageSupport.can_fork?
+
+module Resque
+  module Plugins
+    module NewRelicInstrumentation
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      
+      def around_perform_with_monitoring(*args)
+        begin
+          trace_options = if (defined?(::Backgrounded::Handler::ResqueHandler) && payload_class == ::Backgrounded::Handler::ResqueHandler)
+            {
+              :class_name => args[0],
+              :name => args[2].to_s,
+              :params => @payload,
+              :category => 'OtherTransaction/BackgroundedResqueJob'
+            }
+          else
+            {
+              :class_name => self.name,
+              :name => 'perform',
+              :category => 'OtherTransaction/ResqueJob'
+            }
+          end
+          perform_action_with_newrelic_trace(trace_options) do
+            yield(*args)
+          end
+        ensure
+          NewRelic::Agent.shutdown if RPMContrib::LanguageSupport.can_fork?
+        end
+      end
+    end
+  end
+end
+
+module RPMContrib
+  module Instrumentation
+    module ResqueInstrumentationInstaller
+      def payload_class
+        klass = super
+        klass.instance_eval do
+          extend ::Resque::Plugins::NewRelicInstrumentation
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :resque
+  
+  depends_on do
+    defined?(::Resque::Job) and not NewRelic::Control.instance['disable_resque']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Resque instrumentation'
+  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::Job.class_eval do
+      def self.new(*args)
+        super(*args).extend RPMContrib::Instrumentation::ResqueInstrumentationInstaller
+      end
+    end
+
+    ::Resque.before_first_fork do
+      NewRelic::Agent.manual_start(:dispatcher => :resque,
+                                   :sync_startup => true)
+    end
+
+    ::Resque.after_fork do
+      NewRelic::Agent.after_fork(:force_reconnect => false)
+    end
+  end
+end 

data/lib/rpm_contrib/instrumentation/riak_client.rb

@@ -0,0 +1,48 @@
+DependencyDetection.defer do
+  @name = :riak_client
+
+  depends_on do
+    defined?(::Riak) and not NewRelic::Control.instance['disable_riak_client']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Riak client instrumentation'
+  end
+
+  executes do
+    backend_tracers = proc do
+      add_method_tracer :ping, 'Database/Riak/ping'
+
+      add_method_tracer :list_buckets, 'Database/Riak/list_buckets'
+      add_method_tracer :get_bucket_props, 'Database/Riak/get_bucket_props'
+      add_method_tracer :set_bucket_props, 'Database/Riak/set_bucket_props'
+
+      add_method_tracer :mapred, 'Database/Riak/mapred'
+
+      add_method_tracer :list_keys, 'Database/Riak/list_keys'
+      add_method_tracer :fetch_object, 'Database/Riak/fetch_object'
+      add_method_tracer :reload_object, 'Database/Riak/reload_object'
+      add_method_tracer :store_object, 'Database/Riak/store_object'
+      add_method_tracer :delete_object, 'Database/Riak/delete_object'
+    end
+
+    ::Riak::Client::BeefcakeProtobuffsBackend.class_eval &backend_tracers
+    ::Riak::Client::BeefcakeProtobuffsBackend.class_eval do
+      add_method_tracer :server_info, 'Database/Riak/server_info'
+      add_method_tracer :get_client_id, 'Database/Riak/get_client_id'
+      add_method_tracer :set_client_id, 'Database/Riak/set_client_id'
+    end
+    ::Riak::Client::HTTPBackend.class_eval &backend_tracers
+    ::Riak::Client::HTTPBackend.class_eval do
+      add_method_tracer :stats, 'Database/Riak/stats'
+      add_method_tracer :link_walk, 'Database/Riak/link_walk'
+      add_method_tracer :get_index, 'Database/Riak/get_index'
+      add_method_tracer :search, 'Database/Riak/search'
+      add_method_tracer :update_search_index, 'Database/Riak/update_search_index'
+    end
+
+    ::Riak::RObject.class_eval do
+      add_method_tracer :serialize, 'Database/Riak/serialize'
+    end
+  end
+end

data/lib/rpm_contrib/instrumentation/ripple.rb

@@ -0,0 +1,37 @@
+DependencyDetection.defer do
+  @name = :ripple
+
+  depends_on do
+    defined?(::Ripple) and not
+      NewRelic::Control.instance['disable_ripple']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Ripple instrumentation'
+  end
+
+  executes do
+    ::Ripple::Callbacks::InstanceMethods.class_eval do
+      add_method_tracer :valid?, 'Database/Riak/Ripple/valid?'
+    end
+
+    ::Ripple::Document::Persistence::ClassMethods.class_eval do
+      add_method_tracer :create, 'Database/Riak/Ripple/create'
+      add_method_tracer :destroy_all, 'Database/Riak/Ripple/destroy_all'
+    end
+
+    ::Ripple::Document::Persistence::InstanceMethods.class_eval do
+      add_method_tracer :really_save, 'Database/Riak/Ripple/really_save'
+      add_method_tracer :reload, 'Database/Riak/Ripple/reload'
+      add_method_tracer :delete, 'Database/Riak/Ripple/delete'
+      add_method_tracer :destroy, 'Database/Riak/Ripple/destroy'
+      add_method_tracer :update_attribute, 'Database/Riak/Ripple/update_attribute'
+      add_method_tracer :update_attributes, 'Database/Riak/Ripple/update_attributes'
+    end
+
+    ::Ripple::Document::Finders::ClassMethods.class_eval do
+      add_method_tracer :find, 'Database/Riak/Ripple/find'
+      add_method_tracer :list, 'Database/Riak/Ripple/list'
+    end
+  end
+end

data/lib/rpm_contrib/instrumentation/sinatra.rb

@@ -0,0 +1,30 @@
+DependencyDetection.defer do
+  @name = :sinatra_view
+  
+  depends_on do
+    defined?(::Sinatra::Base) and not NewRelic::Control.instance['disable_sinatra_template']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Sinatra view instrumentation'
+  end
+  
+  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"
+
+        file = "Proc" if file.is_a?(Proc)
+        metrics = ["View/#{engine}/#{file}/Rendering"]
+
+        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/thinking_sphinx.rb

@@ -0,0 +1,22 @@
+DependencyDetection.defer do
+  @name = :thinking_sphinx
+    
+  depends_on do
+    defined?(::ThinkingSphinx) and not ::NewRelic::Control.instance['disable_thinking_sphinx']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Thinking Sphinx instrumentation'
+  end
+  
+  executes do
+    class ::ThinkingSphinx::Search
+      include NewRelic::Agent::MethodTracer
+
+      add_method_tracer :initialize
+      add_method_tracer :populate
+      add_method_tracer :results
+    end
+  end
+end
+

data/lib/rpm_contrib/instrumentation/typhoeus.rb

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

@@ -0,0 +1,22 @@
+DependencyDetection.defer do
+  @name = :ultrasphinx
+    
+  depends_on do
+    defined?(::Ultrasphinx) and not ::NewRelic::Control.instance['disable_ultrasphinx']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Ultrasphinx instrumentation'
+  end
+  
+  executes do
+    class  ::Ultrasphinx::Search
+      include NewRelic::Agent::MethodTracer
+
+      add_method_tracer :run
+      add_method_tracer :results
+    end
+  end
+end
+
+