traceview 3.0.0

data/lib/traceview/inst/excon.rb

@@ -0,0 +1,111 @@
+# Copyright (c) 2015 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module ExconConnection
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :request, ::Excon::Connection)
+        ::TraceView::Util.method_alias(klass, :requests, ::Excon::Connection)
+      end
+
+      def traceview_collect(params)
+        kvs = {}
+        kvs['IsService'] = 1
+        kvs['RemoteProtocol'] = ::TraceView::Util.upcase(@data[:scheme])
+        kvs['RemoteHost'] = @data[:host]
+
+        # Conditionally log query args
+        if TraceView::Config[:excon][:log_args] && (@data[:query] && @data[:query].length)
+          kvs['ServiceArg'] = @data[:path] + '?' + @data[:query]
+        else
+          kvs['ServiceArg'] = @data[:path]
+        end
+
+        # In the case of HTTP pipelining, params could be an array of
+        # request hashes.
+        if params.is_a?(Array)
+          methods = []
+          params.each do |p|
+            methods << ::TraceView::Util.upcase(p[:method])
+          end
+          kvs['HTTPMethods'] = methods.join(', ')[0..1024]
+          kvs['Pipeline'] = true
+        else
+          kvs['HTTPMethod'] = ::TraceView::Util.upcase(params[:method])
+        end
+        kvs['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:excon][:collect_backtraces]
+        kvs
+      rescue => e
+        TraceView.logger.debug "[traceview/debug] Error capturing excon KVs: #{e.message}"
+        TraceView.logger.debug e.backtrace.join('\n') if ::TraceView::Config[:verbose]
+      end
+
+      def requests_with_traceview(pipeline_params)
+        responses = nil
+        TraceView::API.trace('excon', traceview_collect(pipeline_params)) do
+          responses = requests_without_traceview(pipeline_params)
+        end
+        responses
+      end
+
+      def request_with_traceview(params={}, &block)
+        # If we're not tracing, just do a fast return.
+        # If making HTTP pipeline requests (ordered batched)
+        # then just return as we're tracing from parent
+        # <tt>requests</tt>
+        if !TraceView.tracing? || params[:pipeline]
+          return request_without_traceview(params, &block)
+        end
+
+        begin
+          response_context = nil
+
+          # Avoid cross host tracing for blacklisted domains
+          blacklisted = TraceView::API.blacklisted?(@data[:hostname])
+
+          req_context = TraceView::Context.toString()
+          @data[:headers]['X-Trace'] = req_context unless blacklisted
+
+          kvs = traceview_collect(params)
+          kvs['Blacklisted'] = true if blacklisted
+
+          TraceView::API.log_entry('excon', kvs)
+          kvs.clear
+
+          # The core excon call
+          response = request_without_traceview(params, &block)
+
+          # excon only passes back a hash (datum) for HTTP pipelining...
+          # In that case, we should never arrive here but for the OCD, double check
+          # the datatype before trying to extract pertinent info
+          if response.is_a?(Excon::Response)
+            response_context = response.headers['X-Trace']
+            kvs['HTTPStatus'] = response.status
+
+            # If we get a redirect, report the location header
+            if ((300..308).to_a.include? response.status.to_i) && response.headers.key?("Location")
+              kvs["Location"] = response.headers["Location"]
+            end
+
+            if response_context && !blacklisted
+              TraceView::XTrace.continue_service_context(req_context, response_context)
+            end
+          end
+
+          response
+        rescue => e
+          TraceView::API.log_exception('excon', e)
+          raise e
+        ensure
+          TraceView::API.log_exit('excon', kvs) unless params[:pipeline]
+        end
+      end
+    end
+  end
+end
+
+if TraceView::Config[:excon][:enabled] && defined?(::Excon)
+  ::TraceView.logger.info '[traceview/loading] Instrumenting excon' if TraceView::Config[:verbose]
+  ::TraceView::Util.send_include(::Excon::Connection, ::TraceView::Inst::ExconConnection)
+end

data/lib/traceview/inst/faraday.rb

@@ -0,0 +1,73 @@
+module TraceView
+  module Inst
+    module FaradayConnection
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :run_request, ::Faraday::Connection)
+      end
+
+      def run_request_with_traceview(method, url, body, headers, &block)
+        # Only send service KVs if we're not using the Net::HTTP adapter
+        # Otherwise, the Net::HTTP instrumentation will send the service KVs
+        handle_service = !@builder.handlers.include?(Faraday::Adapter::NetHttp) &&
+                          !@builder.handlers.include?(Faraday::Adapter::Excon)
+        TraceView::API.log_entry('faraday')
+
+        result = run_request_without_traceview(method, url, body, headers, &block)
+
+        kvs = {}
+        kvs['Middleware'] = @builder.handlers
+        kvs['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:faraday][:collect_backtraces]
+
+        if handle_service
+          blacklisted = TraceView::API.blacklisted?(@url_prefix.to_s)
+          context = TraceView::Context.toString
+          task_id = TraceView::XTrace.task_id(context)
+
+          # Avoid cross host tracing for blacklisted domains
+          # Conditionally add the X-Trace header to the outgoing request
+          @headers['X-Trace'] = context unless blacklisted
+
+          kvs['IsService'] = 1
+          kvs['RemoteProtocol'] = (@url_prefix.scheme == 'https') ? 'HTTPS' : 'HTTP'
+          kvs['RemoteHost'] = @url_prefix.host
+          kvs['RemotePort'] = @url_prefix.port
+          kvs['ServiceArg'] = url
+          kvs['HTTPMethod'] = method
+          kvs[:HTTPStatus] = result.status
+          kvs['Blacklisted'] = true if blacklisted
+
+          # Re-attach net::http edge unless it's blacklisted or if we don't have a
+          # valid X-Trace header
+          unless blacklisted
+            xtrace = result.headers['X-Trace']
+
+            if TraceView::XTrace.valid?(xtrace) && TraceView.tracing?
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == TraceView::XTrace.task_id(xtrace)
+                TraceView::Context.fromString(xtrace)
+              else
+                TraceView.logger.debug "Mismatched returned X-Trace ID: #{xtrace}"
+              end
+            end
+          end
+        end
+
+        TraceView::API.log('faraday', 'info', kvs)
+        result
+      rescue => e
+        TraceView::API.log_exception('faraday', e)
+        raise e
+      ensure
+        TraceView::API.log_exit('faraday')
+      end
+    end
+  end
+end
+
+if TraceView::Config[:faraday][:enabled]
+  if defined?(::Faraday)
+    TraceView.logger.info '[traceview/loading] Instrumenting faraday' if TraceView::Config[:verbose]
+    ::TraceView::Util.send_include(::Faraday::Connection, ::TraceView::Inst::FaradayConnection)
+  end
+end

data/lib/traceview/inst/http.rb

@@ -0,0 +1,87 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'net/http'
+
+if TraceView::Config[:nethttp][:enabled]
+
+  Net::HTTP.class_eval do
+    def request_with_traceview(*args, &block)
+      # If we're not tracing, just do a fast return. Since
+      # net/http.request calls itself, only trace
+      # once the http session has been started.
+      if !TraceView.tracing? || !started?
+        return request_without_traceview(*args, &block)
+      end
+
+      # Avoid cross host tracing for blacklisted domains
+      blacklisted = TraceView::API.blacklisted?(addr_port)
+
+      TraceView::API.trace('net-http') do
+        opts = {}
+        context = TraceView::Context.toString()
+        task_id = TraceView::XTrace.task_id(context)
+
+        # Collect KVs to report in the info event
+        if args.length && args[0]
+          req = args[0]
+
+          opts['IsService'] = 1
+          opts['RemoteProtocol'] = use_ssl? ? 'HTTPS' : 'HTTP'
+          opts['RemoteHost'] = addr_port
+
+          # Conditionally log query params
+          if TraceView::Config[:nethttp][:log_args]
+            opts['ServiceArg'] = req.path
+          else
+            opts['ServiceArg'] = req.path.split('?').first
+          end
+
+          opts['HTTPMethod'] = req.method
+          opts['Blacklisted'] = true if blacklisted
+          opts['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:nethttp][:collect_backtraces]
+
+          req['X-Trace'] = context unless blacklisted
+        end
+
+        begin
+          # The actual net::http call
+          resp = request_without_traceview(*args, &block)
+
+          # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
+          unless blacklisted
+            xtrace = resp.get_fields('X-Trace')
+            xtrace = xtrace[0] if xtrace && xtrace.is_a?(Array)
+
+            if TraceView::XTrace.valid?(xtrace)
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == TraceView::XTrace.task_id(xtrace)
+                TraceView::Context.fromString(xtrace)
+              else
+                TraceView.logger.debug "Mismatched returned X-Trace ID : #{xtrace}"
+              end
+            end
+          end
+
+          opts['HTTPStatus'] = resp.code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? resp.code.to_i) && resp.header["Location"]
+            opts["Location"] = resp.header["Location"]
+          end
+
+          next resp
+        ensure
+          # Log the info event with the KVs in opts
+          TraceView::API.log('net-http', 'info', opts)
+        end
+      end
+    end
+
+    alias request_without_traceview request
+    alias request request_with_traceview
+
+    TraceView.logger.info '[traceview/loading] Instrumenting net/http' if TraceView::Config[:verbose]
+  end
+end

data/lib/traceview/inst/httpclient.rb

@@ -0,0 +1,173 @@
+# Copyright (c) 2015 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module HTTPClient
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :do_request, ::HTTPClient)
+        ::TraceView::Util.method_alias(klass, :do_request_async, ::HTTPClient)
+        ::TraceView::Util.method_alias(klass, :do_get_stream, ::HTTPClient)
+      end
+
+      def traceview_collect(method, uri, query = nil)
+        kvs = {}
+        kvs['IsService'] = 1
+
+        # Conditionally log URL query params
+        # Because of the hook points, the query arg can come in under <tt>query</tt>
+        # or as a part of <tt>uri</tt> (not both).  Here we handle both cases.
+        if TraceView::Config[:httpclient][:log_args]
+          if query
+            kvs['RemoteURL'] = uri.to_s + '?' + TraceView::Util.to_query(query)
+          else
+            kvs['RemoteURL'] = uri.to_s
+          end
+        else
+          kvs['RemoteURL'] = uri.to_s.split('?').first
+        end
+
+        kvs['HTTPMethod'] = ::TraceView::Util.upcase(method)
+        kvs['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:httpclient][:collect_backtraces]
+        kvs
+      rescue => e
+        TraceView.logger.debug "[traceview/debug] Error capturing httpclient KVs: #{e.message}"
+        TraceView.logger.debug e.backtrace.join('\n') if ::TraceView::Config[:verbose]
+      end
+
+      def do_request_with_traceview(method, uri, query, body, header, &block)
+        # If we're not tracing, just do a fast return.
+        if !TraceView.tracing?
+          return request_without_traceview(method, uri, query, body, header, &block)
+        end
+
+        begin
+          response_context = nil
+
+          # Avoid cross host tracing for blacklisted domains
+          blacklisted = TraceView::API.blacklisted?(uri.hostname)
+
+          kvs = traceview_collect(method, uri, query)
+          kvs['Blacklisted'] = true if blacklisted
+
+          TraceView::API.log_entry('httpclient', kvs)
+          kvs.clear
+
+          req_context = TraceView::Context.toString()
+
+          # Be aware of various ways to call/use httpclient
+          if header.is_a?(Array)
+            header.push ["X-Trace", req_context]
+          elsif header.is_a?(Hash)
+            header['X-Trace'] = req_context unless blacklisted
+          end
+
+          # The core httpclient call
+          response = do_request_without_traceview(method, uri, query, body, header, &block)
+
+          response_context = response.headers['X-Trace']
+          kvs['HTTPStatus'] = response.status_code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? response.status.to_i) && response.headers.key?("Location")
+            kvs["Location"] = response.headers["Location"]
+          end
+
+          if response_context && !blacklisted
+            TraceView::XTrace.continue_service_context(req_context, response_context)
+          end
+
+          response
+        rescue => e
+          TraceView::API.log_exception('httpclient', e)
+          raise e
+        ensure
+          TraceView::API.log_exit('httpclient', kvs)
+        end
+      end
+
+      def do_request_async_with_traceview(method, uri, query, body, header)
+        if TraceView.tracing?
+          # Since async is done by calling Thread.new { .. }, we somehow
+          # have to pass the tracing context into that new thread.  Here
+          # we stowaway the context in the request headers to be picked up
+          # (and removed from req headers) in do_get_stream.
+          if header.is_a?(Array)
+            header.push ["traceview.context", TraceView::Context.toString]
+          elsif header.is_a?(Hash)
+            header['traceview.context'] = TraceView::Context.toString
+          end
+        end
+
+        do_request_async_without_traceview(method, uri, query, body, header)
+      end
+
+      def do_get_stream_with_traceview(req, proxy, conn)
+        unless req.headers.key?("traceview.context")
+          return do_get_stream_without_traceview(req, proxy, conn)
+        end
+
+        # Pickup context and delete the headers stowaway
+        TraceView::Context.fromString req.headers["traceview.context"]
+        req.header.delete "traceview.context"
+
+        begin
+          response = nil
+          response_context = nil
+          uri = req.http_header.request_uri
+          method = req.http_header.request_method
+
+          # Avoid cross host tracing for blacklisted domains
+          blacklisted = TraceView::API.blacklisted?(uri.hostname)
+
+          kvs = traceview_collect(method, uri)
+          kvs['Blacklisted'] = true if blacklisted
+          kvs['Async'] = 1
+
+          TraceView::API.log_entry('httpclient', kvs)
+          kvs.clear
+
+          req_context = TraceView::Context.toString()
+          req.header.add('X-Trace', req_context)
+
+          # The core httpclient call
+          result = do_get_stream_without_traceview(req, proxy, conn)
+
+          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
+          if result.is_a?(::HTTP::Message)
+            response = result
+          else
+            response = conn.pop
+          end
+
+          response_context = response.headers['X-Trace']
+          kvs['HTTPStatus'] = response.status_code
+
+          # If we get a redirect, report the location header
+          if ((300..308).to_a.include? response.status.to_i) && response.headers.key?("Location")
+            kvs["Location"] = response.headers["Location"]
+          end
+
+          if response_context && !blacklisted
+            TraceView::XTrace.continue_service_context(req_context, response_context)
+          end
+
+          # Older HTTPClient < 2.6.0 returns HTTPClient::Connection
+          conn.push response if result.is_a?(::HTTPClient::Connection)
+          result
+        rescue => e
+          TraceView::API.log_exception('httpclient', e)
+          raise e
+        ensure
+          # TraceView::API.log_exit('httpclient', kvs.merge('Async' => 1))
+          TraceView::API.log_exit('httpclient', kvs)
+        end
+      end
+    end
+  end
+end
+
+if TraceView::Config[:httpclient][:enabled] && defined?(::HTTPClient)
+  ::TraceView.logger.info '[traceview/loading] Instrumenting httpclient' if TraceView::Config[:verbose]
+  ::TraceView::Util.send_include(::HTTPClient, ::TraceView::Inst::HTTPClient)
+end

data/lib/traceview/inst/memcache.rb

@@ -0,0 +1,102 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module MemCache
+      include TraceView::API::Memcache
+
+      def self.included(cls)
+        TraceView.logger.info '[traceview/loading] Instrumenting memcache' if TraceView::Config[:verbose]
+
+        cls.class_eval do
+          MEMCACHE_OPS.reject { |m| !method_defined?(m) }.each do |m|
+
+            define_method("#{m}_with_traceview") do |*args|
+              report_kvs = { :KVOp => m }
+              report_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:memcache][:collect_backtraces]
+
+              if TraceView.tracing?
+                TraceView::API.trace('memcache', report_kvs) do
+                  send("#{m}_without_traceview", *args)
+                end
+              else
+                send("#{m}_without_traceview", *args)
+              end
+            end
+
+            class_eval "alias #{m}_without_traceview #{m}"
+            class_eval "alias #{m} #{m}_with_traceview"
+          end
+        end
+
+        [:request_setup, :cache_get, :get_multi].each do |m|
+          if ::MemCache.method_defined? :request_setup
+            cls.class_eval "alias #{m}_without_traceview #{m}"
+            cls.class_eval "alias #{m} #{m}_with_traceview"
+          elsif TraceView::Config[:verbose]
+            TraceView.logger.warn "[traceview/loading] Couldn't properly instrument Memcache: #{m}"
+          end
+        end
+      end
+
+      def get_multi_with_traceview(*args)
+        return get_multi_without_traceview(args) unless TraceView.tracing?
+
+        info_kvs = {}
+
+        begin
+          info_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:memcache][:collect_backtraces]
+
+          if args.last.is_a?(Hash) || args.last.nil?
+            info_kvs[:KVKeyCount] = args.flatten.length - 1
+          else
+            info_kvs[:KVKeyCount] = args.flatten.length
+          end
+        rescue StandardError => e
+          TraceView.logger.debug "[traceview/debug] Error collecting info keys: #{e.message}"
+          TraceView.logger.debug e.backtrace
+        end
+
+        TraceView::API.trace('memcache', { :KVOp => :get_multi }, :get_multi) do
+          values = get_multi_without_traceview(args)
+
+          info_kvs[:KVHitCount] = values.length
+          TraceView::API.log('memcache', 'info', info_kvs)
+
+          values
+        end
+      end
+
+      def request_setup_with_traceview(*args)
+        if TraceView.tracing? && !TraceView.tracing_layer_op?(:get_multi)
+          server, cache_key = request_setup_without_traceview(*args)
+
+          info_kvs = { :KVKey => cache_key, :RemoteHost => server.host }
+          info_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:memcache][:collect_backtraces]
+          TraceView::API.log('memcache', 'info', info_kvs)
+
+          [server, cache_key]
+        else
+          request_setup_without_traceview(*args)
+        end
+      end
+
+      def cache_get_with_traceview(server, cache_key)
+        result = cache_get_without_traceview(server, cache_key)
+
+        info_kvs = { :KVHit => memcache_hit?(result) }
+        info_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:memcache][:collect_backtraces]
+        TraceView::API.log('memcache', 'info', info_kvs)
+
+        result
+      end
+    end # module MemCache
+  end # module Inst
+end # module TraceView
+
+if defined?(::MemCache) && TraceView::Config[:memcache][:enabled]
+  ::MemCache.class_eval do
+    include TraceView::Inst::MemCache
+  end
+end