tingyun_rpm 1.4.2 → 1.5.0

data/lib/ting_yun/http/curb_wrappers.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+require 'ting_yun/http/abstract_request'
+
+    module TingYun
+      module Http
+
+
+    class CurbRequest
+      CURB = 'Curb'.freeze
+      LHOST = 'host'.freeze
+      UHOST = 'Host'.freeze
+
+      def initialize( curlobj )
+        @curlobj = curlobj
+      end
+
+      def type
+        CURB
+      end
+
+      def from
+        "curb%2Fhttp"
+      end
+
+      def host_from_header
+        self[LHOST] || self[UHOST]
+      end
+
+      def host
+        host_from_header || self.uri.host
+      end
+
+      def method
+        @curlobj._ty_http_verb
+      end
+
+      def []( key )
+        @curlobj.headers[ key ]
+      end
+
+      def []=( key, value )
+        @curlobj.headers[ key ] = value
+      end
+
+      def uri
+        @uri ||= TingYun::Agent::HTTPClients::URIUtil.parse_and_normalize_url(@curlobj.url)
+      end
+    end
+
+
+    class CurbResponse < AbstractRequest
+      def initialize(curlobj)
+        @headers = {}
+        @curlobj = curlobj
+      end
+
+      def [](key)
+        @headers[ key.downcase ]
+      end
+
+      def to_hash
+        @headers.dup
+      end
+
+      def append_header_data( data )
+        key, value = data.split( /:\s*/, 2 )
+        @headers[ key.downcase ] = value
+        @curlobj._ty_header_str ||= ''
+        @curlobj._ty_header_str << data
+      end
+
+    end
+
+
+  end
+end

data/lib/ting_yun/http/excon_wrappers.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require 'ting_yun/http/abstract_request'
+
+module TingYun
+  module Http
+
+      class ExconHTTPResponse
+
+        def initialize(response)
+          @response = response
+          # Since HTTP headers are case-insensitive, we normalize all of them to
+          # upper case here, and then also in our [](key) implementation.
+          @normalized_headers = {}
+          headers = response.respond_to?(:headers) ? response.headers : response[:headers]
+          (headers || {}).each do |key, val|
+            @normalized_headers[key.upcase] = val
+          end
+        end
+
+
+        def [](key)
+          @normalized_headers[key.upcase]
+        end
+
+        def to_hash
+          @normalized_headers.dup
+        end
+      end
+
+      class ExconHTTPRequest < AbstractRequest
+        attr_reader :method
+
+        EXCON = "Excon".freeze
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+        COLON = ':'.freeze
+
+        def initialize(datum)
+          @datum = datum
+
+          @method = @datum[:method].to_s.upcase
+          @scheme = @datum[:scheme]
+          @port   = @datum[:port]
+          @path   = @datum[:path]
+        end
+
+        def type
+          EXCON
+        end
+
+        def from
+          "excon%2Fhttp"
+        end
+
+        def host_from_header
+          headers = @datum[:headers]
+          if hostname = (headers[LHOST] || headers[UHOST])
+            hostname.split(COLON).first
+          end
+        end
+
+        def host
+          host_from_header || @datum[:host]
+        end
+
+        def [](key)
+          @datum[:headers][key]
+        end
+
+        def []=(key, value)
+          @datum[:headers] ||= {}
+          @datum[:headers][key] = value
+        end
+
+        def uri
+          URI.parse("#{@scheme}://#{host}:#{@port}#{@path}")
+        end
+      end
+    end
+
+end

data/lib/ting_yun/http/http_client_request.rb

@@ -1,7 +1,7 @@
-require 'ting_yun/http/generic_request'
+require 'ting_yun/http/abstract_request'
 module TingYun
   module Http
-    class HttpClientRequest < GenericRequest
+    class HttpClientRequest < AbstractRequest
       attr_reader :method, :header
 
       def initialize(proxy, *args, &block)

data/lib/ting_yun/http/net_http_request.rb

@@ -1,7 +1,7 @@
-require 'ting_yun/http/generic_request'
+require 'ting_yun/http/abstract_request'
 module TingYun
   module Http
-    class NetHttpRequest < GenericRequest
+    class NetHttpRequest < AbstractRequest
       def initialize(connection, request)
         @connection = connection
         @request = request

data/lib/ting_yun/http/typhoeus_wrappers.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'ting_yun/http/abstract_request'
+
+module TingYun
+  module Http
+
+  class TyphoeusHTTPResponse
+        def initialize(response)
+          @response = response
+        end
+
+        def [](key)
+          unless headers.nil?
+            result = headers[key]
+
+            # Typhoeus 0.5.3 has a bug where asking the headers hash for a
+            # non-existent header will return the hash itself, not what we want.
+            result == headers ? nil : result
+          end
+        end
+
+        def to_hash
+          hash = {}
+          headers.each do |(k,v)|
+            hash[k] = v
+          end
+          hash
+        end
+
+        private
+
+        def headers
+          @response.headers
+        end
+      end
+
+      class TyphoeusHTTPRequest < AbstractRequest
+        def initialize(request)
+          @request = request
+          @uri = case request.url
+            when ::URI then request.url
+            else TingYun::Agent::HTTPClients::URIUtil.parse_and_normalize_url(request.url)
+            end
+        end
+
+        TYPHOEUS = "Typhoeus".freeze
+
+        def type
+          TYPHOEUS
+        end
+        def from
+          "typhoeus%2Fhttp"
+        end
+
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
+        end
+
+        def host
+          host_from_header || @uri.host
+        end
+
+        GET = 'GET'.freeze
+
+        def method
+          (@request.options[:method] || GET).to_s.upcase
+        end
+
+        def [](key)
+          return nil unless @request.options && @request.options[:headers]
+          @request.options[:headers][key]
+        end
+
+        def []=(key, value)
+          @request.options[:headers] ||= {}
+          @request.options[:headers][key] = value
+        end
+
+        def uri
+          @uri
+        end
+      end
+    end
+
+end

data/lib/ting_yun/instrumentation/bunny.rb

@@ -40,7 +40,7 @@ TingYun::Support::LibraryDetection.defer do
               metric_name << "Exchange%2F#{name}/Produce"
             end
             summary_metrics = TingYun::Instrumentation::Support::ExternalHelper.metrics_for_message('RabbitMQ', "#{@channel.connection.host}:#{@channel.connection.port}", 'Produce')
-            TingYun::Agent::Transaction.wrap(state, metric_name , :RabbitMQ, {}, summary_metrics)  do
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(summary_metrics.unshift(metric_name), {}, nil, metric_name) do
               opts[:headers] = {} unless opts[:headers]
               opts[:headers]["TingyunID"] = create_tingyun_id("mq")  if TingYun::Agent.config[:'nbs.transaction_tracer.enabled']
               TingYun::Agent.record_metric("#{metric_name}%2FByte",payload.bytesize) if payload
@@ -148,14 +148,14 @@ TingYun::Support::LibraryDetection.defer do
             state = TingYun::Agent::TransactionState.tl_get
             metric_name = "#{@connection.host}:#{@connection.port}%2FQueue%2F#{args[0]}/Consume"
             summary_metrics = TingYun::Instrumentation::Support::ExternalHelper.metrics_for_message('RabbitMQ', "#{connection.host}:#{connection.port}", 'Consume')
-            TingYun::Agent::Transaction.wrap(state, "Message RabbitMQ/#{metric_name}" , :RabbitMQ, {}, summary_metrics)  do
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(summary_metrics, {}, nil, "Message RabbitMQ/#{metric_name}") do
               basic_get_without_tingyun(*args)
             end
           rescue =>e
             TingYun::Agent.logger.error("Failed to Bunny basic_get_with_tingyun : ", e)
             basic_get_without_tingyun(*args)
           ensure
-            TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+            TingYun::Agent::Transaction.stop(state, Time.now.to_f, summary_metrics)
           end
         end
 

data/lib/ting_yun/instrumentation/curb.rb

@@ -0,0 +1,191 @@
+TingYun::Support::LibraryDetection.defer do
+  named :curb
+
+  CURB_MIN_VERSION = Gem::Version.new("0.8.1")
+
+  depends_on do
+    defined?(::Curl) && defined?(::Curl::CURB_VERSION) &&
+        Gem::Version.new(::Curl::CURB_VERSION) >= CURB_MIN_VERSION
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Curb instrumentation'
+    require 'ting_yun/agent/cross_app/cross_app_tracing'
+    require 'ting_yun/agent/method_tracer_helpers'
+    require 'ting_yun/http/curb_wrappers'
+  end
+
+
+
+  executes do
+    class Curl::Easy
+
+      attr_accessor :_ty_instrumented,
+                    :_ty_http_verb,
+                    :_ty_header_str,
+                    :_ty_original_on_header,
+                    :_ty_original_on_complete,
+                    :_ty_serial
+
+      # We have to hook these three methods separately, as they don't use
+      # Curl::Easy#http
+      def http_head_with_tingyun(*args, &blk)
+        self._ty_http_verb = :HEAD
+        http_head_without_tingyun(*args, &blk)
+      end
+      alias_method :http_head_without_tingyun, :http_head
+      alias_method :http_head, :http_head_with_tingyun
+
+      def http_post_with_tingyun(*args, &blk)
+        self._ty_http_verb = :POST
+        http_post_without_tingyun(*args, &blk)
+      end
+      alias_method :http_post_without_tingyun, :http_post
+      alias_method :http_post, :http_post_with_tingyun
+
+      def http_put_with_tingyun(*args, &blk)
+        self._ty_http_verb = :PUT
+        http_put_without_tingyun(*args, &blk)
+      end
+      alias_method :http_put_without_tingyun, :http_put
+      alias_method :http_put, :http_put_with_tingyun
+
+
+      # Hook the #http method to set the verb.
+      def http_with_tingyun( verb )
+        self._ty_http_verb = verb.to_s.upcase
+        http_without_tingyun( verb )
+      end
+
+      alias_method :http_without_tingyun, :http
+      alias_method :http, :http_with_tingyun
+
+
+      # Hook the #perform method to mark the request as non-parallel.
+      def perform_with_tingyun
+        self._ty_serial = true
+        perform_without_tingyun
+      end
+
+      alias_method :perform_without_tingyun, :perform
+      alias_method :perform, :perform_with_tingyun
+
+      # We override this method in order to ensure access to header_str even
+      # though we use an on_header callback
+      def header_str_with_tingyun
+        if self._ty_serial
+          self._ty_header_str
+        else
+          # Since we didn't install a header callback for a non-serial request,
+          # just fall back to the original implementation.
+          header_str_without_tingyun
+        end
+      end
+
+      alias_method :header_str_without_tingyun, :header_str
+      alias_method :header_str, :header_str_with_tingyun
+    end # class Curl::Easy
+
+    class Curl::Multi
+    
+
+      # Add CAT with callbacks if the request is serial
+      def add_with_tingyun(curl) #THREAD_LOCAL_ACCESS
+        if curl.respond_to?(:_ty_serial) && curl._ty_serial
+          hook_pending_request(curl) if TingYun::Agent.tl_is_execution_traced?
+        end
+
+        return add_without_tingyun( curl )
+      end
+
+      alias_method :add_without_tingyun, :add
+      alias_method :add, :add_with_tingyun
+
+
+      # Trace as an External/Multiple call if the first request isn't serial.
+      def perform_with_tingyun(&blk)
+        return perform_without_tingyun if
+            self.requests.first &&
+                self.requests.first.respond_to?(:_ty_serial) &&
+                self.requests.first._ty_serial
+
+        TingYun::Agent::MethodTracerHelpers.trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
+          perform_without_tingyun(&blk)
+        end
+      end
+
+      alias_method :perform_without_tingyun, :perform
+      alias_method :perform, :perform_with_tingyun
+
+
+      # Instrument the specified +request+ (a Curl::Easy object) and set up cross-application
+      # tracing if it's enabled.
+      def hook_pending_request(request) #THREAD_LOCAL_ACCESS
+        wrapped_request, wrapped_response = wrap_request(request)
+        state = TingYun::Agent::TransactionState.tl_get
+        t0 = Time.now.to_f
+        node = TingYun::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+
+        unless request._ty_instrumented
+          install_header_callback( request, wrapped_response )
+          install_completion_callback( request, t0, node, wrapped_request, wrapped_response )
+          request._ty_instrumented = true
+        end
+      rescue => err
+        TingYun::Agent.logger.error("Untrapped exception", err)
+      end
+
+
+      # Create request and response adapter objects for the specified +request+
+      def wrap_request(request)
+        return TingYun::Http::CurbRequest.new(request),
+            TingYun::Http::CurbResponse.new(request)
+      end
+
+
+
+      # Install a callback that will record the response headers to enable
+      # CAT linking
+      def install_header_callback( request, wrapped_response )
+        original_callback = request.on_header
+        request._ty_original_on_header = original_callback
+        request._ty_header_str = ''
+        request.on_header do |header_data|
+          wrapped_response.append_header_data( header_data )
+
+          if original_callback
+            original_callback.call( header_data )
+          else
+            header_data.length
+          end
+        end
+      end
+
+      # Install a callback that will finish the trace.
+      def install_completion_callback( request, t0, segment, wrapped_request, wrapped_response )
+        original_callback = request.on_complete
+        request._ty_original_on_complete = original_callback
+        request.on_complete do |finished_request|
+          begin
+            TingYun::Agent::CrossAppTracing.finish_trace(TingYun::Agent::TransactionState.tl_get,t0, segment, wrapped_request, wrapped_response )
+          ensure
+            # Make sure the existing completion callback is run, and restore the
+            # on_complete callback to how it was before.
+            original_callback.call( finished_request ) if original_callback
+            remove_instrumentation_callbacks( request )
+          end
+        end
+      end
+
+      def remove_instrumentation_callbacks( request )
+        request.on_complete(&request._ty_original_on_complete)
+        request.on_header(&request._ty_original_on_header)
+        request._ty_instrumented = false
+      end
+
+    end # class Curl::Multi
+
+  end
+
+
+end