tingyun_rpm 1.4.2 → 1.5.0

data/lib/ting_yun/instrumentation/excon.rb

@@ -0,0 +1,131 @@
+TingYun::Support::LibraryDetection.defer do
+  named :excon
+
+  EXCON_MIN_VERSION = Gem::Version.new("0.10.1")
+  EXCON_MIDDLEWARE_MIN_VERSION = Gem::Version.new("0.19.0")
+
+  depends_on do
+    defined?(::Excon) && defined?(::Excon::VERSION)
+  end
+
+  executes do
+    excon_version = Gem::Version.new(::Excon::VERSION)
+    if excon_version >= EXCON_MIN_VERSION
+      install_excon_instrumentation(excon_version)
+    else
+      ::TingYun::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
+    end
+  end
+
+  def install_excon_instrumentation(excon_version)
+    require 'ting_yun/agent/cross_app/cross_app_tracing'
+    require 'ting_yun/http/excon_wrappers'
+
+    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
+      install_middleware_excon_instrumentation
+    else
+      install_legacy_excon_instrumentation
+    end
+  end
+
+  def install_middleware_excon_instrumentation
+    ::TingYun::Agent.logger.info 'Installing middleware-based Excon instrumentation'
+    defaults = Excon.defaults
+
+    if defaults[:middlewares]
+      defaults[:middlewares] << ::Excon::Middleware::TingYunCrossAppTracing
+    else
+      ::TingYun::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
+    end
+  end
+
+  def install_legacy_excon_instrumentation
+    ::TingYun::Agent.logger.info 'Installing legacy Excon instrumentation'
+
+    ::Excon::Connection.install_tingyun_instrumentation
+  end
+
+
+end
+
+module ::Excon
+  class Connection
+    def tingyun_connection_params
+      (@connection || @data)
+    end
+
+    def tingyun_resolved_request_params(request_params)
+      resolved = tingyun_connection_params.merge(request_params)
+      resolved[:headers] = resolved[:headers].merge(request_params[:headers] || {})
+      resolved
+    end
+
+    def request_with_tingyun_trace(params, &block)
+      orig_response = nil
+      resolved_params = tingyun_resolved_request_params(params)
+      wrapped_request = ::TingYun::Http::ExconHTTPRequest.new(resolved_params)
+      ::TingYun::Agent::CrossAppTracing.trace_http_request(wrapped_request) do
+        orig_response = request_without_tingyun_trace(resolved_params, &block)
+        ::TingYun::Http::ExconHTTPResponse.new(orig_response)
+      end
+      orig_response
+    end
+
+    def self.install_tingyun_instrumentation
+      alias request_without_tingyun_trace request
+      alias request request_with_tingyun_trace
+    end
+  end
+
+  module Middleware
+    class TingYunCrossAppTracing
+      TRACE_DATA_IVAR = :@tingyun_trace_data
+
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def request_call(datum)
+        begin
+          # Only instrument this request if we haven't already done so, because
+          # we can get request_call multiple times for requests marked as
+          # :idempotent in the options, but there will be only a single
+          # accompanying response_call/error_call.
+          if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            wrapped_request = ::TingYun::Http::ExconHTTPRequest.new(datum)
+            state = TingYun::Agent::TransactionState.tl_get
+            t0 = Time.now.to_f
+            node = TingYun::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, node, wrapped_request])
+          end
+        rescue => e
+          TingYun::Agent.logger.debug(e)
+        end
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        finish_trace(datum)
+        @stack.response_call(datum)
+      end
+
+      def error_call(datum)
+        finish_trace(datum)
+        @stack.error_call(datum)
+      end
+
+      def finish_trace(datum)
+        trace_data = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+        if trace_data
+          datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
+          t0, segment, wrapped_request = trace_data
+          if datum[:response]
+            wrapped_response = ::TingYun::Http::ExconHTTPResponse.new(datum[:response])
+          end
+          TingYun::Agent::CrossAppTracing.finish_trace(TingYun::Agent::TransactionState.tl_get,t0, segment, wrapped_request, wrapped_response )
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/grape.rb

@@ -21,13 +21,15 @@ TingYun::Support::LibraryDetection.defer do
           name = ["Grape",
                   self.options[:method].first,
                   self.options[:for].to_s,
-                  self.namespace.sub(%r{\A/}, ''), # removing leading slashes
-                  self.options[:path].first.sub(%r{\A/}, ''),
+                  self.namespace.to_s.sub(%r{\A/}, ''), # removing leading slashes
+                  self.options[:path].first.to_s.sub(%r{\A/}, ''),
           ].compact.select{ |n| n.to_s unless n.to_s.empty? }.join("/")
           TingYun::Agent::Transaction.set_default_transaction_name(name, :controller)
           run_without_tingyun(*args)
         rescue => e
           TingYun::Agent.logger.info("Error getting Grape Endpoint Name. Error: #{e.message}. Options: #{self.options.inspect}")
+          TingYun::Agent.notice_error(e,:type=>:exception)
+          raise e
         end
 
       end

data/lib/ting_yun/instrumentation/kafka.rb

@@ -98,7 +98,7 @@ TingYun::Support::LibraryDetection.defer do
               TingYun::Agent.logger.error("Failed to kafka each_message in client : ", e)
               block.call(message)
             ensure
-              TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+              TingYun::Agent::Transaction.stop(state, Time.now.to_f, summary_metrics)
             end
           end
           each_message_without_tingyun(*args, **options, &wrap_block)
@@ -127,7 +127,7 @@ TingYun::Support::LibraryDetection.defer do
                 TingYun::Agent.logger.error("Failed to Bunny call_with_tingyun : ", e)
                 block.call(message)
               ensure
-                TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+                TingYun::Agent::Transaction.stop(state, Time.now.to_f, summary_metrics)
               end
             end
             if options.empty? && args.empty?
@@ -158,7 +158,7 @@ TingYun::Support::LibraryDetection.defer do
                 TingYun::Agent.logger.error("Failed to Bunny call_with_tingyun : ", e)
                 block.call(batch)
               ensure
-                TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+                TingYun::Agent::Transaction.stop(state, Time.now.to_f, summary_metrics)
               end
             end
             if options.empty? && args.empty?

data/lib/ting_yun/instrumentation/memcached.rb

@@ -28,7 +28,7 @@ TingYun::Support::LibraryDetection.defer do
   named :memcached
 
   depends_on do
-    defined?(::Memcached) || (defined?(::Dalli) && defined?(::Dalli::Client)) && false
+    defined?(::Memcached) || (defined?(::Dalli) && defined?(::Dalli::Client))
   end
 
   depends_on do

data/lib/ting_yun/instrumentation/middleware_proxy.rb

@@ -8,15 +8,28 @@ module TingYun
       include TingYun::Instrumentation::MiddlewareTracing
 
 
+      class RackApp
+        def initialize(middleware_class)
+          @middleware = middleware_class
+        end
+
+        def new(app, *args, &block)
+          middleware_instance = @middleware.new(app, *args, &block)
+          MiddlewareProxy.wrap(middleware_instance)
+        end
+      end
 
       def self.is_sinatra_app?(target)
         defined?(::Sinatra::Base) && target.kind_of?(::Sinatra::Base)
       end
 
       def self.needs_wrapping?(target)
-        !target.respond_to?(:_nr_has_middleware_tracing)
+        !target.respond_to?(:_nr_has_middleware_tracing) &&
+        !is_sinatra_app?(target)
       end
 
+
+
       def self.wrap(target, is_app=false)
         if needs_wrapping?(target)
           self.new(target, is_app)
@@ -25,6 +38,9 @@ module TingYun
         end
       end
 
+      def self.for_class(target_class)
+        RackApp.new(target_class)
+      end
 
       attr_reader :target, :category, :transaction_options
 

data/lib/ting_yun/instrumentation/middleware_tracing.rb

@@ -71,7 +71,7 @@ module TingYun
 
           result
         rescue Exception => e
-          TingYun::Agent.notice_error(e)
+          TingYun::Agent.notice_error(e,:type=>:error)
           raise e
         ensure
           TingYun::Agent::Transaction.stop(state)

data/lib/ting_yun/instrumentation/mongo_command_log_subscriber.rb

@@ -60,6 +60,7 @@ module TingYun
       def log_notification_error(event_type, error)
         TingYun::Agent.logger.error("Error during MongoDB #{event_type} event:")
         TingYun::Agent.logger.log_exception(:error, error)
+        TingYun::Agent.notice_error(error,:type=>:exception)
       end
 
 

data/lib/ting_yun/instrumentation/net.rb

@@ -31,30 +31,30 @@ TingYun::Support::LibraryDetection.defer do
       alias :request :request_with_tingyun_trace
 
 
-      class << self
-        def get_response_with_tingyun(uri_or_host, path = nil, port = nil, &block)
-          begin
-            get_response_without_tingyun(uri_or_host, path , port , &block)
-          rescue => e
-            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{uri_or_host.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/net%2Fhttp")
-            raise e
-          end
-        end
-        alias get_response_without_tingyun get_response
-        alias get_response get_response_with_tingyun
-
-        def start_with_tingyun(address, *arg, &block)
-          begin
-            start_without_tingyun(address, *arg, &block)
-          rescue => e
-            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{address.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/net%2Fhttp")
-            raise e
-          end
-        end
-        alias :start_without_tingyun :start
-        alias :start :start_with_tingyun
-
-      end
+      # class << self
+      #   def get_response_with_tingyun(uri_or_host, path = nil, port = nil, &block)
+      #     begin
+      #       get_response_without_tingyun(uri_or_host, path , port , &block)
+      #     rescue => e
+      #       ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{uri_or_host.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/net%2Fhttp")
+      #       raise e
+      #     end
+      #   end
+      #   alias get_response_without_tingyun get_response
+      #   alias get_response get_response_with_tingyun
+      #
+      #   def start_with_tingyun(address, *arg, &block)
+      #     begin
+      #       start_without_tingyun(address, *arg, &block)
+      #     rescue => e
+      #       # ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{address.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/net%2Fhttp")
+      #       raise e
+      #     end
+      #   end
+      #   alias :start_without_tingyun :start
+      #   alias :start :start_with_tingyun
+      #
+      # end
     end
   end
 end

data/lib/ting_yun/instrumentation/rack.rb

@@ -39,14 +39,14 @@ module TingYun
       end
 
 
-      # def use_with_tingyun(middleware_class, *args, &blk)
-      #   if ::TingYun::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-      #     wrapped_middleware_class = ::TingYun::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-      #     use_without_tingyun(wrapped_middleware_class, *args, &blk)
-      #   else
-      #     use_without_tingyun(middleware_class, *args, &blk)
-      #   end
-      # end
+      def use_with_tingyun(middleware_class, *args, &blk)
+        if ::TingYun::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+          wrapped_middleware_class = ::TingYun::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+          use_without_tingyun(wrapped_middleware_class, *args, &blk)
+        else
+          use_without_tingyun(middleware_class, *args, &blk)
+        end
+      end
 
       # We patch this method for a reason that actually has nothing to do with
       # instrumenting rack itself. It happens to be a convenient and
@@ -99,8 +99,8 @@ TingYun::Support::LibraryDetection.defer do
         alias_method :run_without_tingyun, :run
         alias_method :run, :run_with_tingyun
         #
-        # alias_method :use_without_tingyun, :use
-        # alias_method :use, :use_with_tingyun
+        alias_method :use_without_tingyun, :use
+        alias_method :use, :use_with_tingyun
       end
 
     end

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

@@ -14,7 +14,7 @@ module TingYun
 
 
         def tingyun_metric_path(action_name_override = nil)
-          if find_rule(request.request_method.upcase, request.path, request.env, request.filtered_parameters)
+          if TingYun::Agent.config[:'naming.rules_enabled'] && find_rule(request.request_method.upcase, request.path, request.env, request.filtered_parameters)
             return "Rails/#{namespace}/#{name(request.path.slice(1..-1), request.env, request.filtered_parameters, request.cookies)}"
           else
             return  "URL/#{self.env["PATH_INFO"][1..-1].gsub(/\//,'%2F')}" unless TingYun::Agent.config[:'nbs.auto_action_naming']

data/lib/ting_yun/instrumentation/rake.rb

@@ -7,7 +7,7 @@ TingYun::Support::LibraryDetection.defer do
   depends_on do
     defined?(::Rake)&&
         !::TingYun::Agent.config[:'disable_rake'] &&
-        ::TingYun::Agent.config[:'rake.tasks'].any? &&
+        ::TingYun::Agent::Instrumentation::RakeInstrumentation.supported_instrument? &&
         ::TingYun::Agent::Instrumentation::RakeInstrumentation.supported_version?
   end
 
@@ -59,9 +59,9 @@ module TingYun
         end
 
         def self.should_trace? name
-          TingYun::Agent.config[:'rake.tasks'].any? do |task|
-            task == name
-          end
+          return ::TingYun::Agent.config[:'rake.tasks'].include?(name) if ::TingYun::Agent.config[:'rake.tasks'].any?
+          return !TingYun::Agent.config[:'rake.black.tasks'].include?(name) if ::TingYun::Agent.config[:'rake.black.tasks'].any?
+          return false
         end
 
         def self.ensure_at_exit
@@ -106,6 +106,10 @@ module TingYun
             end
           end
         end
+
+        def self.supported_instrument?
+          ::TingYun::Agent.config[:'rake.tasks'].any? or ::TingYun::Agent.config[:'rake.black.tasks'].any?
+        end
       end
     end
   end

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

@@ -74,7 +74,7 @@ module TingYun
         end
 
         def metric_name
-          if find_rule(method, uri, request.header, params)
+          if TingYun::Agent.config[:'naming.rules_enabled'] && find_rule(method, uri, request.header, params)
             @metric_name =  "WebAction/Rails/#{namespace}/#{name(uri, request.header, params, request.cookie)}"
           else
             if TingYun::Agent.config[:'nbs.auto_action_naming']

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

@@ -18,7 +18,7 @@ module TingYun
 
           if event.recordable?
             stack = state.traced_method_stack
-            event.frame = stack.push_frame(state, :action_view, event.time)
+            event.frame = stack.push_frame(state, :action_view, event.time.to_f)
           end
         rescue => e
           log_notification_error(e, name, 'start')
@@ -31,7 +31,7 @@ module TingYun
 
           if event.recordable?
             stack = state.traced_method_stack
-            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end)
+            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end.to_f)
             record_metrics(event, frame)
           end
         rescue => e

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

@@ -49,7 +49,7 @@ module TingYun
           stack  = state.traced_method_stack
           state.timings.sql_duration = state.timings.sql_duration + event.duration
           # enter transaction trace node
-          frame = stack.push_frame(state, :active_record, event.time)
+          frame = stack.push_frame(state, :active_record, event.time.to_f)
 
           sql_sampler.notice_sql(event.payload[:sql], base, config,
                                  TingYun::Helper.milliseconds_to_seconds(event.duration),
@@ -58,7 +58,7 @@ module TingYun
           transaction_sampler.notice_sql(event.payload[:sql], config, event.duration,
                                          state, @explainer, event.payload[:binds], event.payload[:name])
           # exit transaction trace node
-          stack.pop_frame(state, frame, base, event.end, true, metric)
+          stack.pop_frame(state, frame, base, event.end.to_f, true, metric)
         end
 
         def record_metrics(event, config)

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

@@ -228,8 +228,8 @@ module TingYun
             begin
               yield
             rescue => e
-              ::TingYun::Agent.notice_error(e)
-              raise
+              ::TingYun::Agent.notice_error(e,:type=> :exception)
+              raise e
             end
           ensure
             TingYun::Agent::Transaction.stop(state)
@@ -245,7 +245,7 @@ module TingYun
           txn_options[:request] ||= trace_options[:request] if trace_options[:request]
           txn_options[:filtered_params] = trace_options[:params]
           txn_options[:transaction_name] = TingYun::Instrumentation::Support::TransactionNamer.name_for(nil, self, category, trace_options)
-          txn_options[:apdex_start_time] = Time.now
+          txn_options[:apdex_start_time] = Time.now.to_f
 
           txn_options
         end