tingyun_rpm 1.2.0 → 1.3.0

data/lib/ting_yun/instrumentation/rails3/action_view.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 require 'ting_yun/agent'
-require 'ting_yun/agent/method_tracer'
+require 'ting_yun/agent/method_tracer_helpers'
 
 module TingYun
   module Instrumentation
@@ -39,6 +39,10 @@ TingYun::Support::LibraryDetection.defer do
 
   # We can't be sure that this will work with future versions of Rails 3.
   # Currently enabled for Rails 3.1 and 3.2
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_view]
+  end
+
   depends_on do
     defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ([1,2].member?(::Rails::VERSION::MINOR.to_i))
   end
@@ -56,7 +60,7 @@ TingYun::Support::LibraryDetection.defer do
         @details = extract_details(options) if respond_to? :extract_details, true
         identifier = determine_template(options) ? determine_template(options).identifier : nil
         scope_name = "View/#{TingYun::Instrumentation::Rails3::ActionView.template_metric(identifier, options)}/Rendering"
-        TingYun::Agent::MethodTracer.trace_execution_scoped scope_name do
+        TingYun::Agent::MethodTracerHelpers.trace_execution_scoped scope_name do
           render_without_tingyun(context, options)
         end
       end
@@ -70,7 +74,7 @@ TingYun::Support::LibraryDetection.defer do
       def instrument_with_tingyun(name, payload = {}, &block)
         identifier = payload[:identifier]
         scope_name = "View/#{TingYun::Instrumentation::Rails3::ActionView.template_metric(identifier)}/Partial"
-        TingYun::Agent::MethodTracer.trace_execution_scoped(scope_name) do
+        TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(scope_name) do
           instrument_without_tingyun(name, payload, &block)
         end
       end
@@ -102,7 +106,7 @@ TingYun::Support::LibraryDetection.defer do
                     {}
                   end
         str = "View/#{TingYun::Instrumentation::Rails3::ActionView.template_metric(@identifier, options)}/#{TingYun::Agent::Instrumentation::Rails3::ActionView.render_type(@identifier)}"
-        TingYun::Agent::MethodTracer.trace_execution_scoped str do
+        TingYun::Agent::MethodTracerHelpers.trace_execution_scoped str do
           render_without_tingyun(*args, &block)
         end
       end

data/lib/ting_yun/instrumentation/rails4/action_controller.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'ting_yun/instrumentation/support/action_controller_subscriber'
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails4_controller
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_controller]
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 4 Controller instrumentation'
+  end
+
+  executes do
+    ::TingYun::Instrumentation::Rails::ActionControllerSubscriber \
+      .subscribe(/^process_action.action_controller$/)
+  end
+end
+
+

data/lib/ting_yun/instrumentation/rails4/action_view.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/action_view_subscriber'
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails4_view
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_view]
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    !TingYun::Agent.config[:disable_view_instrumentation] &&
+        !TingYun::Instrumentation::Rails::ActionViewSubscriber.subscribed?
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Rails 4 view instrumentation'
+  end
+
+  executes do
+    TingYun::Instrumentation::Rails::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
+  end
+end
+#

data/lib/ting_yun/instrumentation/rails4/active_record.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'ting_yun/instrumentation/support/active_record_subscriber'
+
+TingYun::Support::LibraryDetection.defer do
+  named :active_record_4
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_active_record]
+  end
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+        defined?(::ActiveRecord::VERSION) &&
+        ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !TingYun::Instrumentation::Rails::ActiveRecordSubscriber.subscribed?
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing ActiveRecord 4 instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+                                           TingYun::Instrumentation::Rails::ActiveRecordSubscriber.new)
+    ::TingYun::Instrumentation::Support::ActiveRecordHelper.instrument_additional_methods
+  end
+end

data/lib/ting_yun/instrumentation/rails5/action_cable.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/action_cable_subscriber'
+
+TingYun::Support::LibraryDetection.defer do
+  named  :rails5_action_cable
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_cable]
+  end
+
+  depends_on do
+    defined?(::Rails) &&
+        ::Rails::VERSION::MAJOR.to_i == 5 &&
+        defined?(::ActionCable)
+  end
+
+  depends_on do
+    !TingYun::Agent.config[:disable_action_cable_instrumentation]
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 5 Action Cable instrumentation'
+  end
+
+  executes do
+    # enumerate the specific events we want so that we do not get unexpected additions in the future
+    ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
+                                           TingYun::Instrumentation::Rails::ActionCableSubscriber.new)
+  end
+end

data/lib/ting_yun/instrumentation/rails5/action_controller.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/action_controller_subscriber'
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :rails5_controller
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_controller]
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 5
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 5 Controller instrumentation'
+  end
+
+  executes do
+    ::TingYun::Instrumentation::Rails::ActionControllerSubscriber \
+      .subscribe(/^process_action.action_controller$/)
+  end
+end

data/lib/ting_yun/instrumentation/rails5/action_view.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/action_view_subscriber'
+
+TingYun::Support::LibraryDetection.defer do
+  named  :rails5_view
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_view]
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 5
+  end
+
+  depends_on do
+    !TingYun::Agent.config[:disable_view_instrumentation] &&
+        !TingYun::Instrumentation::Rails::ActionViewSubscriber.subscribed?
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 5 view instrumentation'
+  end
+
+  executes do
+    TingYun::Instrumentation::Rails::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
+  end
+end

data/lib/ting_yun/instrumentation/rails5/active_record.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'ting_yun/instrumentation/support/active_record_subscriber'
+
+TingYun::Support::LibraryDetection.defer do
+  named :active_record_5
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_active_record]
+  end
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+        defined?(::ActiveRecord::VERSION) &&
+        ::ActiveRecord::VERSION::MAJOR.to_i == 5
+  end
+
+  depends_on do
+    !TingYun::Instrumentation::Rails::ActiveRecordSubscriber.subscribed?
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing ActiveRecord 5 instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+                                           TingYun::Instrumentation::Rails::ActiveRecordSubscriber.new)
+    ::TingYun::Instrumentation::Support::ActiveRecordHelper.instrument_additional_methods
+  end
+end

data/lib/ting_yun/instrumentation/rake.rb

@@ -13,6 +13,7 @@ TingYun::Support::LibraryDetection.defer do
 
   executes do
     ::TingYun::Agent.logger.info 'Installing deferred Rake instrumentation'
+    require 'ting_yun/agent/method_tracer_helpers'
   end
 
   executes do
@@ -87,7 +88,7 @@ module TingYun
           task.instance_variable_set(:@__tingyun_instrumented_execute, true)
           task.instance_eval do
             def execute(*args, &block)
-              TingYun::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
+              TingYun::Agent::MethodTracerHelpers.trace_execution_scoped("Rake/execute/#{self.name}") do
                 super
               end
             end
@@ -99,7 +100,7 @@ module TingYun
         def self.instrument_invoke_prerequisites_concurrently(task)
           task.instance_eval do
             def invoke_prerequisites_concurrently(*_)
-              TingYun::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
+              TingYun::Agent::MethodTracerHelpers.trace_execution_scoped("Rake/execute/multitask") do
                 super
               end
             end

data/lib/ting_yun/instrumentation/redis.rb

@@ -6,7 +6,8 @@ TingYun::Support::LibraryDetection.defer do
   named :redis
 
   depends_on do
-    defined?(::Redis)
+    defined?(::Redis) &&
+        !::TingYun::Agent.config[:disable_redis]
   end
 
 
@@ -20,7 +21,7 @@ TingYun::Support::LibraryDetection.defer do
 
     ::Redis::Client.class_eval do
 
-      def record_redis_duration(_1, _2, duration)
+      def record_redis_duration(duration)
         state = TingYun::Agent::TransactionState.tl_get
         if state
           state.timings.rds_duration = state.timings.rds_duration + duration * 1000
@@ -32,7 +33,7 @@ TingYun::Support::LibraryDetection.defer do
       def call_with_tingyun_trace(*args, &blk)
         operation = args[0].is_a?(Array) ? args[0][0] : args[0]
 
-        TingYun::Agent::Datastore.wrap("Redis", operation, nil, method(:record_redis_duration)) do
+        TingYun::Agent::Datastore.wrap("Redis", operation, db, host, port, nil, method(:record_redis_duration)) do
           call_without_tingyun_trace(*args, &blk)
         end
       end
@@ -46,7 +47,7 @@ TingYun::Support::LibraryDetection.defer do
           pipeline = args[0]
           operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? 'multi' : 'pipeline'
 
-          TingYun::Agent::Datastore.wrap("Redis", operation, nil, method(:record_redis_duration)) do
+          TingYun::Agent::Datastore.wrap("Redis", operation, db, host, port, nil, method(:record_redis_duration)) do
             call_pipelined_without_tingyun_trace(*args, &block)
           end
         end
@@ -60,7 +61,7 @@ TingYun::Support::LibraryDetection.defer do
         alias_method :connect_without_tingyun, :connect
 
         def connect(*args, &block)
-          TingYun::Agent::Datastore.wrap("Redis", "connect", nil, method(:record_redis_duration)) do
+          TingYun::Agent::Datastore.wrap("Redis", "connect", db, host, port, nil, method(:record_redis_duration)) do
             connect_without_tingyun(*args, &block)
           end
         end

data/lib/ting_yun/instrumentation/sidekiq.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :sidekiq
+
+  depends_on do
+    defined?(::Sidekiq) && !TingYun::Agent.config[:disable_sidekiq]
+  end
+
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Sidekiq Instrumentation'
+    require 'ting_yun/instrumentation/support/controller_instrumentation'
+  end
+
+  executes do
+    class TingYun::SidekiqInstrumentation
+      include TingYun::Instrumentation::Support::ControllerInstrumentation
+      def call(worker_instance, msg, queue, *_)
+        trace_args = if worker_instance.respond_to?(:tingyun_trace_args)
+                       worker_instance.tingyun_trace_args(msg, queue)
+                     else
+                       self.class.default_trace_args(msg)
+                     end
+        perform_action_with_tingyun_trace(trace_args) do
+          yield
+        end
+      end
+
+      def self.default_trace_args(msg)
+        {
+            :name => 'perform',
+            :class_name => msg['class'],
+            :category => 'BackgroundAction/Sidekiq'
+        }
+      end
+    end
+
+    class Sidekiq::Extensions::DelayedClass
+      def tingyun_trace_args(msg, queue)
+        (target, method_name, _args) = YAML.load(msg['args'][0])
+        {
+            :name => method_name,
+            :class_name => target.name,
+            :category => 'BackgroundAction/Sidekiq'
+        }
+      rescue => e
+        TingYun::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+        TingYun::SidekiqInstrumentation.default_trace_args(msg)
+      end
+    end
+
+    Sidekiq.configure_server do |config|
+      config.server_middleware do |chain|
+        chain.add TingYun::SidekiqInstrumentation
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/sinatra/action.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/split_controller'
+require 'ting_yun/instrumentation/support/sinatra_helper'
+module TingYun
+  module Instrumentation
+    module Sinatra
+      module Action
+
+        include TingYun::Instrumentation::Support::SplitController
+
+        def tingyun_metric_path(current_class, path)
+          if find_rule(request.request_method.upcase, path, request.env, request.params)
+            return "Sinatra/#{current_class}/#{namespace}/#{name(path.slice(1..-1), request.env, request.params, request.cookies)}"
+          else
+            return self.env["PATH_INFO"] unless TingYun::Agent.config[:'nbs.auto_action_naming']
+            "Sinatra/#{current_class}/#{path}(#{request.request_method.upcase})".squeeze("/")
+          end
+        end
+      end
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :sinatra_action
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_controller]
+  end
+
+  depends_on do
+    defined?(::Sinatra) && defined?(::Sinatra::Base) && TingYun::Instrumentation::Support::SinatraHelper.version_supported?
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Sinatra action instrumentation'
+  end
+
+  executes do
+    ::Sinatra::Base.class_eval do
+
+      class << self
+        private
+        alias :route_without_origin_path :route
+
+        def route(verb, path, options = {}, &block)
+          res = route_without_origin_path(verb, path, options = {}, &block)
+          @routes[verb].last << path
+          res
+        end
+      end
+
+
+      private
+      alias :route_eval_without_tingyun_trace :route_eval
+
+      def ty_get_path(base)
+        if routes = base.routes[@request.request_method]
+          routes.each do |pattern, keys, conditions, block, origin_path|
+            route = @request.path_info
+            route = '/' if route.empty? and not settings.empty_path_info?
+            next unless pattern.match(route)
+            return (origin_path.respond_to?(:source) ? origin_path.source : origin_path)
+          end
+        end
+        ty_get_path(base.superclass) if base.superclass.respond_to?(:routes)
+      end
+
+
+      def route_eval(*args, &block)
+
+        self.class.class_eval do
+          require 'ting_yun/instrumentation/support/parameter_filtering'
+          require 'ting_yun/instrumentation/support/controller_instrumentation'
+          include TingYun::Instrumentation::Sinatra::Action
+        end
+
+        params = TingYun::Instrumentation::Support::ParameterFiltering.flattened_filter_request_parameters(@params)
+
+        TingYun::Instrumentation::Support::ControllerInstrumentation.perform_action_with_tingyun_trace(
+            :category => :sinatra,
+            :name     => @request.path_info,
+            :path     => tingyun_metric_path(self.class.name, ty_get_path(self.class)),
+            :params   => params,
+            :class_name => self.class.name,
+            :request => @request
+        ) do
+          route_eval_without_tingyun_trace(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/sinatra/view.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'ting_yun/agent/method_tracer_helpers'
+require 'ting_yun/instrumentation/support/sinatra_helper'
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :sinatra_view
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_view]
+  end
+
+  depends_on do
+    defined?(::Sinatra) && defined?(::Sinatra::Templates) && TingYun::Instrumentation::Support::SinatraHelper.version_supported?
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Sinatra view instrumentation'
+  end
+
+  executes do
+    ::Sinatra::Templates.class_eval do
+
+      def tingyun_template_metric(*args, &block)
+        engine, data, options = args[0..2]
+        eat_errors = options[:eat_errors]
+        views = options[:views] || settings.views || "./views"
+        if data.is_a?(Symbol)
+          body, path, line = settings.templates[data]
+          unless body.respond_to?(:call)
+            template = Tilt[engine]
+            found = false
+            @preferred_extension = engine.to_s
+            find_template(views, data, template) do |file|
+              path ||= file
+              if found = File.exist?(file)
+                path = file
+                break
+              end
+            end
+            path = nil if eat_errors and not found  # layout_missing
+          end
+        else
+          path = nil
+        end
+        if path
+          path = path.gsub(settings.root,'') if respond_to?(:settings) && settings.root
+          "View/#{path.gsub(/\.+\//,'')}/Rendering".squeeze("/")
+        end
+      end
+
+      def render_with_tingyun(*args, &block) # engine, data, options = {}, locals = {}, &block
+        scope_name = tingyun_template_metric(*args, &block)
+        if scope_name
+          TingYun::Agent::MethodTracerHelpers.trace_execution_scoped scope_name do
+            render_without_tingyun(*args, &block)
+          end
+        else
+          render_without_tingyun(*args, &block)
+        end
+      end
+
+      alias_method :render_without_tingyun, :render
+      alias_method :render, :render_with_tingyun
+    end
+  end
+end

data/lib/ting_yun/instrumentation/support/action_cable_subscriber.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/evented_subscriber'
+require 'ting_yun/agent/method_tracer_helpers'
+require 'ting_yun/agent/transaction'
+
+module TingYun
+  module Instrumentation
+    module Rails
+      class ActionCableSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
+
+        PERFORM_ACTION = 'perform_action.action_cable'.freeze
+
+        def start (name, id, payload) #THREAD_LOCAL_ACCESS
+          state = TingYun::Agent::TransactionState.tl_get
+          return unless state.execution_traced?
+          event = super
+          if event.name == PERFORM_ACTION
+            start_transaction state, event
+          else
+            start_recording_metrics state, event
+          end
+        rescue => e
+          log_notification_error e, name, 'start'
+        end
+
+        def finish (name, id, payload) #THREAD_LOCAL_ACCESS
+          state = TingYun::Agent::TransactionState.tl_get
+          return unless state.execution_traced?
+          event = super
+          notice_error payload if payload.key? :exception
+          if event.name == PERFORM_ACTION
+            finish_transaction state
+          else
+            stop_recording_metrics state, event
+          end
+        rescue => e
+          log_notification_error e, name, 'finish'
+        end
+
+        private
+
+        def start_transaction state, event
+          TingYun::Agent::Transaction.start(state, :action_cable, :transaction_name => transaction_name_from_event(event))
+        end
+
+        def finish_transaction state
+          TingYun::Agent::Transaction.stop(state)
+        end
+
+        def start_recording_metrics state, event
+          expected_scope = TingYun::Agent::MethodTracerHelpers::trace_execution_scoped_header(state, event.time.to_f)
+          event.payload[:expected_scope] =  expected_scope
+        end
+
+        def stop_recording_metrics state, event
+          expected_scope = event.payload.delete :expected_scope
+          metric_name = metric_name_from_event event
+          TingYun::Agent::MethodTracerHelpers::trace_execution_scoped_footer(state, event.time.to_f, metric_name, [], expected_scope, {:metric => true}, event.end.to_f)
+        end
+
+        def transaction_name_from_event event
+          "WebAction/ActionCable/#{event.payload[:channel_class]}%2F#{event.payload[:action]}"
+        end
+
+        def metric_name_from_event event
+          "ActionCable/#{event.payload[:channel_class]}%2F#{action_name_from_event(event)}"
+        end
+
+        DOT_ACTION_CABLE = ".action_cable".freeze
+        EMPTY_STRING = "".freeze
+
+        def action_name_from_event event
+          event.name.gsub DOT_ACTION_CABLE, EMPTY_STRING
+        end
+
+        def notice_error payload
+          TingYun::Agent.notice_error payload[:exception_object]
+        end
+      end
+    end
+  end
+end