appoptics_apm 4.0.2 → 4.0.3

data/lib/appoptics_apm/api/util.rb

@@ -9,7 +9,7 @@ module AppOpticsAPM
   module API
     ##
     # General utility methods for the gem
-    module Util
+    module Util #:nodoc:
       BACKTRACE_CUTOFF = 200
 
       # Internal: Check whether the provided key is reserved or not. Reserved

data/lib/appoptics_apm/base.rb

@@ -61,6 +61,7 @@ module AppOpticsAPMBase
 
   # Occurs only on Jruby.  Indicates that Joboe (the java instrumentation)
   # has already started tracing before it hit the JRuby instrumentation.
+  # It is used in Rack#call if there is a context when entering rack
   thread_local :has_incoming_context
 
   # Indicates the existence of a valid X-Trace request header

data/lib/appoptics_apm/frameworks/sinatra/templates.rb

@@ -44,7 +44,7 @@ module AppOpticsAPM
             begin
               render_without_appoptics(engine, data, options, locals, &block)
             ensure
-              ::AppOpticsAPM::API.log_exit(:render, report_kvs)
+              ::AppOpticsAPM::API.log_exit(:render, report_kvs, :render)
             end
           end
         else

data/lib/appoptics_apm/inst/rack.rb

@@ -4,142 +4,166 @@
 require 'uri'
 require 'cgi'
 
-module AppOpticsAPM
-  ##
-  # AppOpticsAPM::Rack
-  #
-  # The AppOpticsAPM::Rack middleware used to sample a subset of incoming
-  # requests for instrumentation and reporting.  Tracing context can
-  # be received here (via the X-Trace HTTP header) or initiated here
-  # based on configured tracing mode.
-  #
-  # After the rack layer passes on to the following layers (Rails, Sinatra,
-  # Padrino, Grape), then the instrumentation downstream will
-  # automatically detect whether this is a sampled request or not
-  # and act accordingly. (to instrument or not)
-  #
-  class Rack
-    attr_reader :app
-
-    def initialize(app)
-      @app = app
-    end
+if AppOpticsAPM.loaded
+  module AppOpticsAPM
+    ##
+    # AppOpticsAPM::Rack
+    #
+    # The AppOpticsAPM::Rack middleware used to sample a subset of incoming
+    # requests for instrumentation and reporting.  Tracing context can
+    # be received here (via the X-Trace HTTP header) or initiated here
+    # based on configured tracing mode.
+    #
+    # After the rack layer passes on to the following layers (Rails, Sinatra,
+    # Padrino, Grape), then the instrumentation downstream will
+    # automatically detect whether this is a sampled request or not
+    # and act accordingly. (to instrument or not)
+    #
+    class Rack
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def collect(req, env)
+        report_kvs = {}
 
-    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
 
-      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 AppOpticsAPM::Config[:rack][:log_args]
+            report_kvs[:'Query-String']     = ::CGI.unescape(req.query_string) unless req.query_string.empty?
+          end
 
-        if AppOpticsAPM::Config[:rack][:log_args]
-          report_kvs[:'Query-String']     = ::CGI.unescape(req.query_string) unless req.query_string.empty?
+          # 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.AppOpticsAPM.Version'] = ::AppOpticsAPM::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.
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] Rack KV collection error: #{e.inspect}"
         end
-
-        # 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.AppOpticsAPM.Version'] = ::AppOpticsAPM::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.
-        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Rack KV collection error: #{e.inspect}"
+        report_kvs
       end
-      report_kvs
-    end
 
-    def call(env)
-      start = Time.now
-      status = 500
-      req = ::Rack::Request.new(env)
-      req_url = req.url   # saving it here because rails3.2 overrides it when there is a 500 error
-
-      # 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 AppOpticsAPM.tracing? && AppOpticsAPM.layer == :rack
-        AppOpticsAPM.logger.debug "[appoptics_apm/rack] Rack skipped!"
-        return @app.call(env)
-      end
+      def call(env)
+        start = Time.now
+        status = 500
+        req = ::Rack::Request.new(env)
+        req_url = req.url   # saving it here because rails3.2 overrides it when there is a 500 error
+
+        # 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 AppOpticsAPM.tracing? && AppOpticsAPM.layer == :rack
+          AppOpticsAPM.logger.debug "[appoptics_apm/rack] Rack skipped!"
+          return @app.call(env)
+        end
 
-      begin
-        report_kvs = {}
+        begin
+          report_kvs = {}
 
-        report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
+          report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
 
-        # 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 = AppOpticsAPM::XTrace.valid?(xtrace) ? xtrace : nil
+          # 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 = AppOpticsAPM::XTrace.valid?(xtrace) ? xtrace : nil
 
-        # Under JRuby, JAppOpticsAPM may have already started a trace.  Make note of this
-        # if so and don't clear context on log_end (see appoptics_apm/api/logging.rb)
-        AppOpticsAPM.has_incoming_context = AppOpticsAPM.tracing?
-        AppOpticsAPM.has_xtrace_header = xtrace_header
-        AppOpticsAPM.is_continued_trace = AppOpticsAPM.has_incoming_context || AppOpticsAPM.has_xtrace_header
+          # Under JRuby, JAppOpticsAPM may have already started a trace.  Make note of this
+          # if so and don't clear context on log_end (see appoptics_apm/api/logging.rb)
+          AppOpticsAPM.has_incoming_context = AppOpticsAPM.tracing?
+          AppOpticsAPM.has_xtrace_header = xtrace_header
+          AppOpticsAPM.is_continued_trace = AppOpticsAPM.has_incoming_context || AppOpticsAPM.has_xtrace_header
 
-        xtrace = AppOpticsAPM::API.log_start(:rack, xtrace_header, report_kvs)
+          xtrace = AppOpticsAPM::API.log_start(:rack, xtrace_header, report_kvs)
 
-        # We only trace a subset of requests based off of sample rate so if
-        # AppOpticsAPM::API.log_start really did start a trace, we act accordingly here.
-        if AppOpticsAPM.tracing?
-          report_kvs = collect(req, env)
+          # We only trace a subset of requests based off of sample rate so if
+          # AppOpticsAPM::API.log_start really did start a trace, we act accordingly here.
+          if AppOpticsAPM.tracing?
+            report_kvs = collect(req, env)
 
-          # We log an info event with the HTTP KVs found in AppOpticsAPM::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.
-          AppOpticsAPM::API.log_info(:rack, report_kvs)
+            # We log an info event with the HTTP KVs found in AppOpticsAPM::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.
+            AppOpticsAPM::API.log_info(:rack, report_kvs)
 
-          status, headers, response = @app.call(env)
+            status, headers, response = @app.call(env)
 
-          xtrace = AppOpticsAPM::API.log_end(:rack, :Status => status)
+            xtrace = AppOpticsAPM::API.log_end(:rack, :Status => status)
 
-        else
-          status, headers, response = @app.call(env)
-        end
+          else
+            status, headers, response = @app.call(env)
+          end
 
-        [status, headers, response]
-      rescue Exception => e
-        # it is ok to rescue Exception here because we are reraising it (we just need a chance to log_end)
-        if AppOpticsAPM.tracing?
-          AppOpticsAPM::API.log_exception(:rack, e)
-          xtrace = AppOpticsAPM::API.log_end(:rack, :Status => 500, 'TransactionName' => transaction_name(env))
+          [status, headers, response]
+        rescue Exception => e
+          # it is ok to rescue Exception here because we are reraising it (we just need a chance to log_end)
+          if AppOpticsAPM.tracing?
+            AppOpticsAPM::API.log_exception(:rack, e)
+            xtrace = AppOpticsAPM::API.log_end(:rack, :Status => 500, 'TransactionName' => transaction_name(env))
+          end
+          raise
+        ensure
+          if headers && AppOpticsAPM::XTrace.valid?(xtrace)
+            unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
+              headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+            end
+          end
         end
-        raise
       ensure
-        if headers && AppOpticsAPM::XTrace.valid?(xtrace)
-          unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
-            headers['X-Trace'] = xtrace if headers.is_a?(Hash)
-          end
+        unless ::AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
+          status = status.to_i
+          error = status.between?(500,599) ? 1 : 0
+          duration =(1000 * 1000 * (Time.now - start)).round(0)
+          AppOpticsAPM::Span.createHttpSpan(transaction_name(env), req_url, duration, status, req.request_method, error)
         end
       end
-    ensure
-      unless ::AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
-        status = status.to_i
-        error = status.between?(500,599) ? 1 : 0
-        duration =(1000 * 1000 * (Time.now - start)).round(0)
-        AppOpticsAPM::Span.createHttpSpan(transaction_name(env), req_url, duration, status, req.request_method, error)
+
+      def self.noop?
+        false
+      end
+
+      private
+
+      def transaction_name(env)
+        if env['appoptics_apm.controller'] || env['appoptics_apm.action']
+          [env['appoptics_apm.controller'], env['appoptics_apm.action']].join('.')
+        end
       end
     end
+  end
+else
+  module AppOpticsAPM
+    class Rack
+      attr_reader :app
 
-    private
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
 
-    def transaction_name(env)
-      if env['appoptics_apm.controller'] || env['appoptics_apm.action']
-        [env['appoptics_apm.controller'], env['appoptics_apm.action']].join('.')
+      def self.noop?
+        true
       end
     end
   end

data/lib/appoptics_apm/instrumentation.rb

@@ -4,7 +4,7 @@
 module AppOpticsAPM
   ##
   # The Inst module holds all of the instrumentation extensions for various
-  # libraries suchs as Redis, Dalli and Resque.
+  # libraries such as Redis, Dalli and Resque.
   module Inst
     def self.load_instrumentation
       # Load the general instrumentation

data/lib/appoptics_apm/version.rb

@@ -8,7 +8,7 @@ module AppOpticsAPM
   module Version
     MAJOR = 4
     MINOR = 0
-    PATCH = 2
+    PATCH = 3
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/test/instrumentation/httpclient_test.rb

@@ -18,6 +18,10 @@ unless defined?(JRUBY_VERSION)
       AppOpticsAPM::Config[:tracing_mode] = :always
     end
 
+    def teardown
+      clear_all_traces
+    end
+
     def test_reports_version_init
       init_kvs = ::AppOpticsAPM::Util.build_init_report
       assert init_kvs.key?('Ruby.httpclient.Version')
@@ -25,8 +29,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_get_request
-      clear_all_traces
-
       response = nil
 
       AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -55,8 +57,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_get_with_header_hash
-      clear_all_traces
-
       response = nil
 
       AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -85,8 +85,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_get_with_header_array
-      clear_all_traces
-
       response = nil
 
       AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -115,8 +113,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_post_request
-      clear_all_traces
-
       response = nil
 
       AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -145,8 +141,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_async_get
-      clear_all_traces
-
       conn = nil
 
       AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -180,8 +174,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_cross_app_tracing
-      clear_all_traces
-
       response = nil
 
       AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -217,8 +209,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_requests_with_errors
-      clear_all_traces
-
       result = nil
       begin
         AppOpticsAPM::API.start_trace('httpclient_tests') do
@@ -249,8 +239,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_log_args_when_true
-      clear_all_traces
-
       @log_args = AppOpticsAPM::Config[:httpclient][:log_args]
       AppOpticsAPM::Config[:httpclient][:log_args] = true
 
@@ -276,8 +264,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_log_args_when_false
-      clear_all_traces
-
       @log_args = AppOpticsAPM::Config[:httpclient][:log_args]
       AppOpticsAPM::Config[:httpclient][:log_args] = false
 
@@ -303,8 +289,6 @@ unless defined?(JRUBY_VERSION)
     end
 
     def test_without_tracing
-      clear_all_traces
-
       clnt = HTTPClient.new
       clnt.get('http://127.0.0.1:8101/', :query => { :keyword => 'ruby', :lang => 'en' })
 

data/test/instrumentation/mongo_v1_test.rb

@@ -344,7 +344,7 @@ if Gem.loaded_specs['mongo'].version.to_s < '2.0.0'
       validate_event_keys(traces[1], @entry_kvs)
       validate_event_keys(traces[2], @exit_kvs)
 
-      result.must_equal nil
+      result.must_be_nil
       traces[1]['Collection'].must_equal "testCollection"
       traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:mongo][:collect_backtraces]
       traces[1]['QueryOp'].must_equal "find"

data/test/instrumentation/rack_test.rb

@@ -139,7 +139,7 @@ class RackTestApp < Minitest::Test
 
     get "/no/controller/here"
 
-    assert_equal nil, test_action
+    assert_nil test_action
     assert_equal "http://example.org/no/controller/here", test_url
     assert_equal 404, test_status
     assert_equal "GET", test_method

data/test/instrumentation/sequel_mysql2_test.rb

@@ -344,7 +344,7 @@ if defined?(::Sequel) && !defined?(JRUBY_VERSION)
         traces[1]['Query'].must_equal "select_by_name"
       end
 
-      traces[1]['QueryArgs'].must_equal nil
+      traces[1]['QueryArgs'].must_be_nil
       traces[1]['IsPreparedStatement'].must_equal "true"
       traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:sequel][:collect_backtraces]
       validate_event_keys(traces[2], @exit_kvs)