traceview 3.0.0

data/lib/traceview/inst/rack.rb

@@ -0,0 +1,122 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'uri'
+require 'cgi'
+
+module TraceView
+  class Rack
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def collect(req, env)
+      report_kvs = {}
+
+      begin
+        report_kvs['HTTP-Host']        = req.host
+        report_kvs['Port']             = req.port
+        report_kvs['Proto']            = req.scheme
+        report_kvs[:Method]            = req.request_method
+        report_kvs['AJAX']             = true if req.xhr?
+        report_kvs['ClientIP']         = req.ip
+
+        if TraceView::Config[:rack][:log_args]
+          report_kvs['Query-String']     = ::CGI.unescape(req.query_string) unless req.query_string.empty?
+        end
+
+        report_kvs['X-TV-Meta']         = env['HTTP_X_TV_META']          if env.key?('HTTP_X_TV_META')
+
+        # Report any request queue'ing headers.  Report as 'Request-Start' or the summed Queue-Time
+        report_kvs['Request-Start']     = env['HTTP_X_REQUEST_START']    if env.key?('HTTP_X_REQUEST_START')
+        report_kvs['Request-Start']     = env['HTTP_X_QUEUE_START']      if env.key?('HTTP_X_QUEUE_START')
+        report_kvs['Queue-Time']        = env['HTTP_X_QUEUE_TIME']       if env.key?('HTTP_X_QUEUE_TIME')
+
+        report_kvs['Forwarded-For']     = env['HTTP_X_FORWARDED_FOR']    if env.key?('HTTP_X_FORWARDED_FOR')
+        report_kvs['Forwarded-Host']    = env['HTTP_X_FORWARDED_HOST']   if env.key?('HTTP_X_FORWARDED_HOST')
+        report_kvs['Forwarded-Proto']   = env['HTTP_X_FORWARDED_PROTO']  if env.key?('HTTP_X_FORWARDED_PROTO')
+        report_kvs['Forwarded-Port']    = env['HTTP_X_FORWARDED_PORT']   if env.key?('HTTP_X_FORWARDED_PORT')
+
+        report_kvs['Ruby.TraceView.Version'] = ::TraceView::Version::STRING
+        report_kvs['ProcessID']         = Process.pid
+        report_kvs['ThreadID']          = Thread.current.to_s[/0x\w*/]
+      rescue StandardError => e
+        # Discard any potential exceptions. Debug log and report whatever we can.
+        TraceView.logger.debug "[traceview/debug] Rack KV collection error: #{e.inspect}"
+      end
+      report_kvs
+    end
+
+    def call(env)
+      rack_skipped = false
+
+      # In the case of nested Ruby apps such as Grape inside of Rails
+      # or Grape inside of Grape, each app has it's own instance
+      # of rack middleware.  We avoid tracing rack more than once and
+      # instead start instrumenting from the first rack pass.
+
+      # If we're already tracing a rack layer, dont't start another one.
+      if TraceView.tracing? && TraceView.layer == 'rack'
+        rack_skipped = true
+        TraceView.logger.debug "[traceview/rack] Rack skipped!"
+        return @app.call(env)
+      end
+
+      req = ::Rack::Request.new(env)
+      report_kvs = {}
+
+      if TraceView::Config[:rack][:log_args]
+        report_kvs[:URL] = ::CGI.unescape(req.fullpath)
+      else
+        report_kvs[:URL] = ::CGI.unescape(req.path)
+      end
+
+      # Check for and validate X-Trace request header to pick up tracing context
+      xtrace = env.is_a?(Hash) ? env['HTTP_X_TRACE'] : nil
+      xtrace_header = xtrace if xtrace && TraceView::XTrace.valid?(xtrace)
+
+      # Under JRuby, JTraceView may have already started a trace.  Make note of this
+      # if so and don't clear context on log_end (see traceview/api/logging.rb)
+      TraceView.has_incoming_context = TraceView.tracing?
+      TraceView.has_xtrace_header = xtrace_header
+      TraceView.is_continued_trace = TraceView.has_incoming_context or TraceView.has_xtrace_header
+
+      TraceView::API.log_start('rack', xtrace_header, report_kvs)
+
+      # We only trace a subset of requests based off of sample rate so if
+      # TraceView::API.log_start really did start a trace, we act accordingly here.
+      if TraceView.tracing?
+        report_kvs = collect(req, env)
+
+        # We log an info event with the HTTP KVs found in TraceView::Rack.collect
+        # This is done here so in the case of stacks that try/catch/abort
+        # (looking at you Grape) we're sure the KVs get reported now as
+        # this code may not be returned to later.
+        TraceView::API.log_info('rack', report_kvs)
+
+        status, headers, response = @app.call(env)
+
+        xtrace = TraceView::API.log_end('rack', :Status => status)
+      else
+        status, headers, response = @app.call(env)
+      end
+
+      [status, headers, response]
+    rescue Exception => e
+      unless rack_skipped
+        TraceView::API.log_exception('rack', e)
+        xtrace = TraceView::API.log_end('rack', :Status => 500)
+      end
+      raise
+    ensure
+      if !rack_skipped && headers && TraceView::XTrace.valid?(xtrace)
+        unless defined?(JRUBY_VERSION) && TraceView.is_continued_trace?
+          headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+        end
+      end
+    end
+  end
+end
+

data/lib/traceview/inst/redis.rb

@@ -0,0 +1,271 @@
+# Copyright (c) 2014 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module Redis
+      module Client
+        # The operations listed in this constant skip collecting KVKey
+        NO_KEY_OPS = [:keys, :randomkey, :scan, :sdiff, :sdiffstore, :sinter,
+                      :sinterstore, :smove, :sunion, :sunionstore, :zinterstore,
+                      :zunionstore, :publish, :select, :eval, :evalsha, :script]
+
+        # Instead of a giant switch statement, we use a hash constant to map out what
+        # KVs need to be collected for each of the many many Redis operations
+        # Hash formatting by undiagnosed OCD
+        KV_COLLECT_MAP = {
+          :brpoplpush  => { :destination  => 2 }, :rpoplpush   => { :destination  => 2 },
+          :sdiffstore  => { :destination  => 1 }, :sinterstore => { :destination  => 1 },
+          :sunionstore => { :destination  => 1 }, :zinterstore => { :destination  => 1 },
+          :zunionstore => { :destination  => 1 }, :publish     => { :channel      => 1 },
+          :incrby      => { :increment    => 2 }, :incrbyfloat => { :increment    => 2 },
+          :pexpire     => { :milliseconds => 2 }, :pexpireat   => { :milliseconds => 2 },
+          :expireat    => { :timestamp    => 2 }, :decrby      => { :decrement    => 2 },
+          :psetex      => { :ttl     => 2 },      :restore  => { :ttl     => 2 },
+          :setex       => { :ttl     => 2 },      :setnx    => { :ttl     => 2 },
+          :move        => { :db      => 2 },      :select   => { :db      => 1 },
+          :lindex      => { :index   => 2 },      :getset   => { :value   => 2 },
+          :keys        => { :pattern => 1 },      :expire   => { :seconds => 2 },
+          :rename      => { :newkey  => 2 },      :renamenx => { :newkey  => 2 },
+          :getbit      => { :offset  => 2 },      :setbit   => { :offset  => 2 },
+          :setrange    => { :offset  => 2 },      :evalsha  => { :sha     => 1 },
+          :getrange    => { :start => 2, :end       => 3 },
+          :zrange      => { :start => 2, :end       => 3 },
+          :bitcount    => { :start => 2, :stop      => 3 },
+          :lrange      => { :start => 2, :stop      => 3 },
+          :zrevrange   => { :start => 2, :stop      => 3 },
+          :hincrby     => { :field => 2, :increment => 3 },
+          :smove           => { :source    => 1, :destination => 2 },
+          :bitop           => { :operation => 1, :destkey     => 2 },
+          :hincrbyfloat    => { :field     => 2, :increment   => 3 },
+          :zremrangebyrank => { :start     => 2, :stop        => 3 }
+        }
+
+        # The following operations don't require any special handling. For these,
+        # we only collect KVKey and KVOp
+        #
+        # :append, :blpop, :brpop, :decr, :del, :dump, :exists,
+        # :hgetall, :hkeys, :hlen, :hvals, :hmset, :incr, :linsert,
+        # :llen, :lpop, :lpush, :lpushx, :lrem, :lset, :ltrim,
+        # :persist, :pttl, :hscan, :rpop, :rpush, :rpushx, :sadd,
+        # :scard, :sismember, :smembers, :strlen, :sort, :spop,
+        # :srandmember, :srem, :sscan, :ttl, :type, :zadd, :zcard,
+        # :zcount, :zincrby, :zrangebyscore, :zrank, :zrem,
+        # :zremrangebyscore, :zrevrank, :zrevrangebyscore, :zscore
+        #
+        # For the operations in NO_KEY_OPS (above) we only collect
+        # KVOp (no KVKey)
+
+        def self.included(klass)
+          # We wrap two of the Redis methods to instrument
+          # operations
+          ::TraceView::Util.method_alias(klass, :call, ::Redis::Client)
+          ::TraceView::Util.method_alias(klass, :call_pipeline, ::Redis::Client)
+        end
+
+        # Given any Redis operation command array, this method
+        # extracts the Key/Values to report to the TraceView
+        # dashboard.
+        #
+        # @param command [Array] the Redis operation array
+        # @param r [Return] the return value from the operation
+        # @return [Hash] the Key/Values to report
+        def extract_trace_details(command, r)
+          kvs = {}
+          op = command.first
+
+          begin
+            kvs[:KVOp] = command[0]
+            kvs[:RemoteHost] = @options[:host]
+
+            unless NO_KEY_OPS.include?(op) || (command[1].is_a?(Array) && command[1].count > 1)
+              if command[1].is_a?(Array)
+                kvs[:KVKey] = command[1].first
+              else
+                kvs[:KVKey] = command[1]
+              end
+            end
+
+            if KV_COLLECT_MAP[op]
+              # Extract KVs from command for this op
+              KV_COLLECT_MAP[op].each { |k, v|
+                kvs[k] = command[v]
+              }
+            else
+              # This case statement handle special cases not handled
+              # by KV_COLLECT_MAP
+              case op
+              when :set
+                if command.count > 3
+                  options = command[3]
+                  kvs[:ex] = options[:ex] if options.key?(:ex)
+                  kvs[:px] = options[:px] if options.key?(:px)
+                  kvs[:nx] = options[:nx] if options.key?(:nx)
+                  kvs[:xx] = options[:xx] if options.key?(:xx)
+                end
+
+              when :get
+                kvs[:KVHit] = r.nil? ? 0 : 1
+
+              when :hdel, :hexists, :hget, :hset, :hsetnx
+                kvs[:field] = command[2] unless command[2].is_a?(Array)
+                if op == :hget
+                  kvs[:KVHit] = r.nil? ? 0 : 1
+                end
+
+              when :eval
+                if command[1].length > 1024
+                  kvs[:Script] = command[1][0..1023] + '(...snip...)'
+                else
+                  kvs[:Script] = command[1]
+                end
+
+              when :script
+                kvs[:subcommand] = command[1]
+                kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:redis][:collect_backtraces]
+                if command[1] == 'load'
+                  if command[1].length > 1024
+                    kvs[:Script] = command[2][0..1023] + '(...snip...)'
+                  else
+                    kvs[:Script] = command[2]
+                  end
+                elsif command[1] == :exists
+                  if command[2].is_a?(Array)
+                    kvs[:KVKey] = command[2].inspect
+                  else
+                    kvs[:KVKey] = command[2]
+                  end
+                end
+
+              when :mget
+                if command[1].is_a?(Array)
+                  kvs[:KVKeyCount] = command[1].count
+                else
+                  kvs[:KVKeyCount] = command.count - 1
+                end
+                values = r.select { |i| i }
+                kvs[:KVHitCount] = values.count
+
+              when :hmget
+                kvs[:KVKeyCount] = command.count - 2
+                values = r.select { |i| i }
+                kvs[:KVHitCount] = values.count
+
+              when :mset, :msetnx
+                if command[1].is_a?(Array)
+                  kvs[:KVKeyCount] = command[1].count / 2
+                else
+                  kvs[:KVKeyCount] = (command.count - 1) / 2
+                end
+              end # case op
+            end # if KV_COLLECT_MAP[op]
+
+          rescue StandardError => e
+            TraceView.logger.debug "Error collecting redis KVs: #{e.message}"
+            TraceView.logger.debug e.backtrace.join('\n')
+          end
+
+          kvs
+        end
+
+        # Extracts the Key/Values to report from a pipelined
+        # call to the TraceView dashboard.
+        #
+        # @param pipeline [Redis::Pipeline] the Redis pipeline instance
+        # @return [Hash] the Key/Values to report
+        def extract_pipeline_details(pipeline)
+          kvs = {}
+
+          begin
+            kvs[:RemoteHost] = @options[:host]
+            kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:redis][:collect_backtraces]
+
+            command_count = pipeline.commands.count
+            kvs[:KVOpCount] = command_count
+
+            if pipeline.commands.first == :multi
+              kvs[:KVOp] = :multi
+            else
+              kvs[:KVOp] = :pipeline
+            end
+
+            # Report pipelined operations  if the number
+            # of ops is reasonable
+            if command_count < 12
+              ops = []
+              pipeline.commands.each do |c|
+                ops << c.first
+              end
+              kvs[:KVOps] = ops.join(', ')
+            end
+          rescue StandardError => e
+            TraceView.logger.debug "[traceview/debug] Error extracting pipelined commands: #{e.message}"
+            TraceView.logger.debug e.backtrace
+          end
+          kvs
+        end
+
+        #
+        # The wrapper method for Redis::Client.call.  Here
+        # (when tracing) we capture KVs to report and pass
+        # the call along
+        #
+        def call_with_traceview(command, &block)
+          if TraceView.tracing?
+            ::TraceView::API.log_entry('redis', {})
+
+            begin
+              r = call_without_traceview(command, &block)
+              report_kvs = extract_trace_details(command, r)
+              r
+            rescue StandardError => e
+              ::TraceView::API.log_exception('redis', e)
+              raise
+            ensure
+              ::TraceView::API.log_exit('redis', report_kvs)
+            end
+
+          else
+            call_without_traceview(command, &block)
+          end
+        end
+
+        #
+        # The wrapper method for Redis::Client.call_pipeline.  Here
+        # (when tracing) we capture KVs to report and pass the call along
+        #
+        def call_pipeline_with_traceview(pipeline)
+          if TraceView.tracing?
+            # Fall back to the raw tracing API so we can pass KVs
+            # back on exit (a limitation of the TraceView::API.trace
+            # block method)  This removes the need for an info
+            # event to send additonal KVs
+            ::TraceView::API.log_entry('redis', {})
+
+            report_kvs = extract_pipeline_details(pipeline)
+
+            begin
+              call_pipeline_without_traceview(pipeline)
+            rescue StandardError => e
+              ::TraceView::API.log_exception('redis', e)
+              raise
+            ensure
+              ::TraceView::API.log_exit('redis', report_kvs)
+            end
+          else
+            call_pipeline_without_traceview(pipeline)
+          end
+        end
+
+      end
+    end
+  end
+end
+
+if TraceView::Config[:redis][:enabled]
+  if defined?(::Redis) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0')
+    TraceView.logger.info '[traceview/loading] Instrumenting redis' if TraceView::Config[:verbose]
+    ::TraceView::Util.send_include(::Redis::Client, ::TraceView::Inst::Redis::Client)
+  end
+end
+

data/lib/traceview/inst/resque.rb

@@ -0,0 +1,192 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'socket'
+require 'json'
+
+module TraceView
+  module Inst
+    module Resque
+      def self.included(base)
+        base.send :extend, ::Resque
+      end
+
+      def extract_trace_details(op, klass, args)
+        report_kvs = {}
+
+        begin
+          report_kvs[:Op] = op.to_s
+          report_kvs[:Class] = klass.to_s if klass
+
+          if TraceView::Config[:resque][:log_args]
+            kv_args = args.to_json
+
+            # Limit the argument json string to 1024 bytes
+            if kv_args.length > 1024
+              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
+            else
+              report_kvs[:Args] = kv_args
+            end
+          end
+
+          report_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:resque][:collect_backtraces]
+        rescue
+        end
+
+        report_kvs
+      end
+
+      def enqueue_with_traceview(klass, *args)
+        if TraceView.tracing?
+          report_kvs = extract_trace_details(:enqueue, klass, args)
+
+          TraceView::API.trace('resque-client', report_kvs, :enqueue) do
+            args.push(:parent_trace_id => TraceView::Context.toString) if TraceView::Config[:resque][:link_workers]
+            enqueue_without_traceview(klass, *args)
+          end
+        else
+          enqueue_without_traceview(klass, *args)
+        end
+      end
+
+      def enqueue_to_with_traceview(queue, klass, *args)
+        if TraceView.tracing? && !TraceView.tracing_layer_op?(:enqueue)
+          report_kvs = extract_trace_details(:enqueue_to, klass, args)
+          report_kvs[:Queue] = queue.to_s if queue
+
+          TraceView::API.trace('resque-client', report_kvs) do
+            args.push(:parent_trace_id => TraceView::Context.toString) if TraceView::Config[:resque][:link_workers]
+            enqueue_to_without_traceview(queue, klass, *args)
+          end
+        else
+          enqueue_to_without_traceview(queue, klass, *args)
+        end
+      end
+
+      def dequeue_with_traceview(klass, *args)
+        if TraceView.tracing?
+          report_kvs = extract_trace_details(:dequeue, klass, args)
+
+          TraceView::API.trace('resque-client', report_kvs) do
+            dequeue_without_traceview(klass, *args)
+          end
+        else
+          dequeue_without_traceview(klass, *args)
+        end
+      end
+    end
+
+    module ResqueWorker
+      def perform_with_traceview(job)
+        report_kvs = {}
+        last_arg = nil
+
+        begin
+          report_kvs[:Op] = :perform
+
+          # Set these keys for the ability to separate out
+          # background tasks into a separate app on the server-side UI
+          report_kvs[:Controller] = :Resque
+          report_kvs[:Action] = :perform
+
+          report_kvs['HTTP-Host'] = Socket.gethostname
+          report_kvs[:URL] = '/resque/' + job.queue
+          report_kvs[:Method] = 'NONE'
+          report_kvs[:Queue] = job.queue
+
+          report_kvs[:Class] = job.payload['class']
+
+          if TraceView::Config[:resque][:log_args]
+            kv_args = job.payload['args'].to_json
+
+            # Limit the argument json string to 1024 bytes
+            if kv_args.length > 1024
+              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
+            else
+              report_kvs[:Args] = kv_args
+            end
+          end
+
+          last_arg = job.payload['args'].last
+        rescue
+        end
+
+        if last_arg.is_a?(Hash) && last_arg.key?('parent_trace_id')
+          begin
+            # Since the enqueue was traced, we force trace the actual job execution and reference
+            # the enqueue trace with ParentTraceID
+            report_kvs[:ParentTraceID] = last_arg['parent_trace_id']
+            job.payload['args'].pop
+
+          rescue
+          end
+
+          # Force this trace regardless of sampling rate so that child trace can be
+          # link to parent trace.
+          TraceView::API.start_trace('resque-worker', nil, report_kvs.merge('Force' => true)) do
+            perform_without_traceview(job)
+          end
+
+        else
+          TraceView::API.start_trace('resque-worker', nil, report_kvs) do
+            perform_without_traceview(job)
+          end
+        end
+      end
+    end
+
+    module ResqueJob
+      def fail_with_traceview(exception)
+        if TraceView.tracing?
+          TraceView::API.log_exception('resque', exception)
+        end
+        fail_without_traceview(exception)
+      end
+    end
+  end
+end
+
+if defined?(::Resque)
+  TraceView.logger.info '[traceview/loading] Instrumenting resque' if TraceView::Config[:verbose]
+
+  ::Resque.module_eval do
+    include TraceView::Inst::Resque
+
+    [:enqueue, :enqueue_to, :dequeue].each do |m|
+      if method_defined?(m)
+        module_eval "alias #{m}_without_traceview #{m}"
+        module_eval "alias #{m} #{m}_with_traceview"
+      elsif TraceView::Config[:verbose]
+        TraceView.logger.warn "[traceview/loading] Couldn't properly instrument Resque (#{m}).  Partial traces may occur."
+      end
+    end
+  end
+
+  if defined?(::Resque::Worker)
+    ::Resque::Worker.class_eval do
+      include TraceView::Inst::ResqueWorker
+
+      if method_defined?(:perform)
+        alias perform_without_traceview perform
+        alias perform perform_with_traceview
+      elsif TraceView::Config[:verbose]
+        TraceView.logger.warn '[traceview/loading] Couldn\'t properly instrument ResqueWorker (perform).  Partial traces may occur.'
+      end
+    end
+  end
+
+  if defined?(::Resque::Job)
+    ::Resque::Job.class_eval do
+      include TraceView::Inst::ResqueJob
+
+      if method_defined?(:fail)
+        alias fail_without_traceview fail
+        alias fail fail_with_traceview
+      elsif TraceView::Config[:verbose]
+        TraceView.logger.warn '[traceview/loading] Couldn\'t properly instrument ResqueWorker (fail).  Partial traces may occur.'
+      end
+    end
+  end
+end
+
+