wireframe-rpm_contrib 1.0.12.7 → 2.1.6.1

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

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

@@ -1,54 +1,90 @@
+require 'rpm_contrib/language_support'
 
-module RPMContrib
-  module Instrumentation
-    # == 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.
-    module ResqueInstrumentation
-      ::Resque::Job.class_eval do
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-        
-        old_perform_method = instance_method(:perform)
+# call this now so it is memoized before potentially forking worker processes
+RPMContrib::LanguageSupport.can_fork?
 
-        define_method(:perform) do
-          NewRelic::Agent.reset_stats if NewRelic::Agent.respond_to? :reset_stats
+module Resque
+  module Plugins
+    module NewRelicInstrumentation
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      
+      def around_perform_with_monitoring(*args)
+        begin
           perform_action_with_newrelic_trace(trace_options) do
-            old_perform_method.bind(self).call
+            yield(*args)
           end
-
-          NewRelic::Agent.shutdown unless defined?(::Resque.before_child_exit)
+        ensure
+          NewRelic::Agent.shutdown if RPMContrib::LanguageSupport.can_fork?
         end
-
-        private
-        def backgrounded_job?
-          defined?(::Backgrounded::Handler::ResqueHandler) && payload_class == ::Backgrounded::Handler::ResqueHandler
-        end
-        def trace_options
-          if backgrounded_job?
-            {
-              :class_name => args[0],
-              :name => args[2].to_s,
-              :params => @payload,
-              :category => 'OtherTransaction/BackgroundedResqueJob'
-            }
-          else
-            class_name = (payload_class || self.class).name
-            {
-              :class_name => class_name,
-              :name => 'perform',
-              :category => 'OtherTransaction/ResqueJob'
-            }
-          end
+      end
+      private
+      def backgrounded_job?
+        defined?(::Backgrounded::Handler::ResqueHandler) && payload_class == ::Backgrounded::Handler::ResqueHandler
+      end
+      def trace_options
+        if backgrounded_job?
+          {
+            :class_name => args[0],
+            :name => args[2].to_s,
+            :params => @payload,
+            :category => 'OtherTransaction/BackgroundedResqueJob'
+          }
+        else
+          class_name = (payload_class || self.class).name
+          {
+            :class_name => class_name,
+            :name => 'perform',
+            :category => 'OtherTransaction/ResqueJob'
+          }
         end
       end
+    end
+  end
+end
 
-      if defined?(::Resque.before_child_exit)
-        ::Resque.before_child_exit do |worker|
-          NewRelic::Agent.shutdown
+module RPMContrib
+  module Instrumentation
+    module ResqueInstrumentationInstaller
+      def payload_class
+        klass = super
+        klass.instance_eval do
+          extend ::Resque::Plugins::NewRelicInstrumentation
         end
       end
     end
   end
-end if defined?(::Resque::Job) and not NewRelic::Control.instance['disable_resque']
+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
+
+

data/lib/rpm_contrib/instrumentation/workling.rb

@@ -0,0 +1,27 @@
+# Workling instrumentation contributed by Chad Ingram of Aurora Feint
+#
+DependencyDetection.defer do
+  @name = :workling
+  
+  depends_on do
+    defined?(::Workling) and not ::NewRelic::Control.instance['disable_workling']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Workling instrumentation'
+  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