newrelic_rpm 3.9.9.275 → 3.10.0.279

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -95,10 +95,14 @@ DependencyDetection.defer do
     ActionController::Base.class_eval do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-      # Compare with #alias_method_chain, which is not available in
-      # Rails 1.1:
+      def perform_action_with_newrelic_trace_wrapper
+        options = {}
+        options[:params] = (respond_to?(:filter_parameters)) ? filter_parameters(params) : params
+        perform_action_with_newrelic_trace(options) { perform_action_without_newrelic_trace }
+      end
+
       alias_method :perform_action_without_newrelic_trace, :perform_action
-      alias_method :perform_action, :perform_action_with_newrelic_trace
+      alias_method :perform_action, :perform_action_with_newrelic_trace_wrapper
       private :perform_action
 
       # determine the path that is used in the metric name for

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -19,15 +19,6 @@ module NewRelic
           end
 
           def process_action(*args) #THREAD_LOCAL_ACCESS
-            # skip instrumentation if we are in an ignored action
-            if _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
-              txn = NewRelic::Agent::Transaction.tl_current
-              txn.ignore! if txn
-              NewRelic::Agent.disable_all_tracing do
-                return super
-              end
-            end
-
             perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :path => newrelic_metric_path, :params => request.filtered_parameters, :class_name => self.class.name)  do
               super
             end

data/lib/new_relic/agent/instrumentation/sinatra.rb

@@ -85,8 +85,11 @@ module NewRelic
 
         module ClassMethods
           def newrelic_middlewares
-            [ NewRelic::Rack::AgentHooks,
-              NewRelic::Rack::BrowserMonitoring ]
+            middlewares = [NewRelic::Rack::BrowserMonitoring]
+            if NewRelic::Rack::AgentHooks.needed?
+              middlewares << NewRelic::Rack::AgentHooks
+            end
+            middlewares
           end
 
           def build_with_newrelic(*args, &block)
@@ -126,7 +129,7 @@ module NewRelic
             txn_name = TransactionNamer.transaction_name_for_route(env, request)
             unless txn_name.nil?
               ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                "#{self.class.name}/#{txn_name}", :category => :sinatra)
+                "#{self.class.name}/#{txn_name}", :sinatra)
             end
           rescue => e
             ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
@@ -136,19 +139,13 @@ module NewRelic
         end
 
         def dispatch_with_newrelic #THREAD_LOCAL_ACCESS
-          if ignore_request?
-            env['newrelic.ignored'] = true
-            txn = ::NewRelic::Agent::Transaction.tl_current
-            txn.ignore! if txn
-            return dispatch_without_newrelic
-          end
-
           request_params = get_request_params
+          filtered_params = ParameterFiltering::apply_filters(request.env, request_params || {})
 
           name = TransactionNamer.initial_transaction_name(request)
           perform_action_with_newrelic_trace(:category => :sinatra,
                                              :name => name,
-                                             :params => request_params) do
+                                             :params => filtered_params) do
             dispatch_and_notice_errors_with_newrelic
           end
         end
@@ -171,7 +168,7 @@ module NewRelic
           ::NewRelic::Agent.notice_error(env['sinatra.error']) if had_error
         end
 
-        def ignore_request?
+        def do_not_trace?
           Ignorer.should_ignore?(self, :routes)
         end
 

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -90,6 +90,7 @@ module NewRelic
         return '' unless js_enabled_and_ready? # fast exit
 
         state = NewRelic::Agent::TransactionState.tl_get
+
         return '' unless insert_js?(state) # slower exit
 
         bt_config = browser_timing_config(state)

data/lib/new_relic/agent/new_relic_service.rb

@@ -469,6 +469,8 @@ module NewRelic
           end
         end
 
+        log_response(response)
+
         case response
         when Net::HTTPSuccess
           true # do nothing
@@ -488,16 +490,17 @@ module NewRelic
         response
       end
 
+      def log_response(response)
+        ::NewRelic::Agent.logger.debug "Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'"
+      end
+
       # Decompresses the response from the server, if it is gzip
       # encoded, otherwise returns it verbatim
       def decompress_response(response)
-        if response['content-encoding'] != 'gzip'
-          ::NewRelic::Agent.logger.debug "Uncompressed content returned"
-          response.body
+        if response['content-encoding'] == 'gzip'
+          Zlib::GzipReader.new(StringIO.new(response.body)).read
         else
-          ::NewRelic::Agent.logger.debug "Decompressing return value"
-          i = Zlib::GzipReader.new(StringIO.new(response.body))
-          i.read
+          response.body
         end
       end
 

data/lib/new_relic/agent/parameter_filtering.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+# This file is distributed under New Relic"s license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module ParameterFiltering
+      extend self
+
+      def apply_filters(env, params)
+        params = filter_using_rails(env, params)
+        params = filter_rack_file_data(env, params)
+        params
+      end
+
+      def filter_using_rails(env, params)
+        return params unless defined?(ActionDispatch::Http::ParameterFilter) && env.key?("action_dispatch.parameter_filter")
+        filters = env["action_dispatch.parameter_filter"]
+        ActionDispatch::Http::ParameterFilter.new(filters).filter(params)
+      end
+
+      def filter_rack_file_data(env, params)
+        content_type = env["CONTENT_TYPE"]
+        multipart = content_type && content_type.start_with?("multipart")
+
+        params.inject({}) do |memo, (k,v)|
+          if multipart && v.is_a?(Hash) && v[:tempfile]
+            memo[k] = "[FILE]"
+          else
+            memo[k] = v
+          end
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/supported_versions.rb

@@ -113,6 +113,13 @@ module NewRelic
         :url         => "https://rubygems.org/gems/rack",
         :feed        => "https://rubygems.org/gems/rack/versions.atom"
       },
+      :grape =>
+      {
+        :type        => :web,
+        :supported   => [">= 0.2.0"],
+        :url         => "https://rubygems.org/gems/grape",
+        :feed        => "https://rubygems.org/gems/grape/versions.atom"
+      },
 
       # Database
       :activerecord =>

data/lib/new_relic/agent/traced_method_stack.rb

@@ -6,7 +6,7 @@ module NewRelic
   module Agent
     class TracedMethodFrame
       attr_reader :tag
-      attr_accessor :name, :start_time, :children_time, :category
+      attr_accessor :name, :start_time, :children_time
       def initialize(tag, start_time)
         @tag = tag
         @start_time = start_time

data/lib/new_relic/agent/transaction.rb

@@ -22,16 +22,21 @@ module NewRelic
       TASK_PREFIX                  = 'OtherTransaction/Background/'.freeze
       RACK_PREFIX                  = 'Controller/Rack/'.freeze
       SINATRA_PREFIX               = 'Controller/Sinatra/'.freeze
+      GRAPE_PREFIX                 = 'Controller/Grape/'.freeze
       OTHER_TRANSACTION_PREFIX     = 'OtherTransaction/'.freeze
 
       CONTROLLER_MIDDLEWARE_PREFIX = 'Controller/Middleware/Rack'.freeze
 
       NESTED_TRACE_STOP_OPTIONS    = { :metric => true }.freeze
-      WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :middleware].freeze
+      WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :grape, :middleware].freeze
+      TRANSACTION_NAMING_SOURCES   = [:child, :api].freeze
 
       MIDDLEWARE_SUMMARY_METRICS   = ['Middleware/all'.freeze].freeze
       EMPTY_SUMMARY_METRICS        = [].freeze
 
+      TRACE_OPTIONS_SCOPED         = { :metric => true, :scoped_metric => true }.freeze
+      TRACE_OPTIONS_UNSCOPED       = { :metric => true, :scoped_metric => false }.freeze
+
       # A Time instance for the start time, never nil
       attr_accessor :start_time
 
@@ -43,7 +48,8 @@ module NewRelic
       attr_accessor :exceptions,
                     :filtered_params,
                     :jruby_cpu_start,
-                    :process_cpu_start
+                    :process_cpu_start,
+                    :http_response_code
 
       # Give the current transaction a request context.  Use this to
       # get the URI and referer.  The request is interpreted loosely
@@ -58,7 +64,8 @@ module NewRelic
                   :metrics,
                   :gc_start_snapshot,
                   :category,
-                  :name_from_child
+                  :frame_stack,
+                  :cat_path_hashes
 
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
@@ -71,63 +78,46 @@ module NewRelic
         TransactionState.tl_get.current_transaction
       end
 
-      def self.set_default_transaction_name(name, options = {}) #THREAD_LOCAL_ACCESS
+      def self.set_default_transaction_name(name, category = nil, segment_name = nil) #THREAD_LOCAL_ACCESS
         txn  = tl_current
-        name = txn.make_transaction_name(name, options[:category])
-
-        if txn.frame_stack.empty?
-          txn.set_default_transaction_name(name, options)
-        else
-          txn.frame_stack.last.name = name
-          txn.frame_stack.last.category = options[:category] if options[:category]
-        end
+        name = txn.make_transaction_name(name, category)
+        txn.name_last_frame(segment_name || name)
+        txn.set_default_transaction_name(name, category)
       end
 
-      def self.set_overriding_transaction_name(name, options = {}) #THREAD_LOCAL_ACCESS
+      def self.set_overriding_transaction_name(name, category = nil) #THREAD_LOCAL_ACCESS
         txn = tl_current
         return unless txn
 
-        name = txn.make_transaction_name(name, options[:category])
+        name = txn.make_transaction_name(name, category)
 
-        if txn.frame_stack.empty?
-          txn.set_overriding_transaction_name(name, options)
-        else
-          txn.frame_stack.last.name = name
-          txn.frame_stack.last.category = options[:category] if options[:category]
+        txn.name_last_frame(name)
+        txn.set_overriding_transaction_name(name, category)
+      end
 
-          # Parent transaction also takes this name, but only if they
-          # are both/neither web transactions.
-          child_is_web_category = transaction_category_is_web?(txn.frame_stack.last.category)
-          txn_is_web_category   = transaction_category_is_web?(txn.category)
+      def self.wrap(state, name, category, options = {})
+        Transaction.start(state, category, options.merge(:transaction_name => name))
 
-          if (child_is_web_category == txn_is_web_category)
-            txn.name_from_api = name
-          end
+        begin
+          # We shouldn't raise from Transaction.start, but only wrap the yield
+          # to be absolutely sure we don't report agent problems as app errors
+          yield
+        rescue => e
+          Transaction.notice_error(e)
+          raise e
+        ensure
+          Transaction.stop(state)
         end
       end
 
-      def make_transaction_name(name, category=nil)
-        namer = Instrumentation::ControllerInstrumentation::TransactionNamer
-        "#{namer.prefix_for_category(self, category)}#{name}"
-      end
-
       def self.start(state, category, options)
         category ||= :controller
         txn = state.current_transaction
 
         if txn
-          if options[:filtered_params] && !options[:filtered_params].empty?
-            txn.filtered_params = options[:filtered_params]
-          end
-
-          nested_frame = NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
-          nested_frame.name = options[:transaction_name]
-          nested_frame.category = category
-          txn.frame_stack << nested_frame
+          txn.create_nested_frame(state, category, options)
         else
-          txn = Transaction.new(category, options)
-          state.reset(txn)
-          txn.start(state)
+          txn = start_new_transaction(state, category, options)
         end
 
         txn
@@ -136,6 +126,13 @@ module NewRelic
         nil
       end
 
+      def self.start_new_transaction(state, category, options)
+        txn = Transaction.new(category, options)
+        state.reset(txn)
+        txn.start(state)
+        txn
+      end
+
       FAILED_TO_STOP_MESSAGE = "Failed during Transaction.stop because there is no current transaction"
 
       def self.stop(state, end_time=Time.now)
@@ -146,22 +143,12 @@ module NewRelic
           return
         end
 
+        nested_frame = txn.frame_stack.pop
+
         if txn.frame_stack.empty?
-          txn.stop(state, end_time)
+          txn.stop(state, end_time, nested_frame)
           state.reset
         else
-          nested_frame = txn.frame_stack.pop
-
-          # Parent transaction inherits the name of the first child
-          # to complete, if they are both/neither web transactions.
-          nested_is_web_category = transaction_category_is_web?(nested_frame.category)
-          txn_is_web_category    = transaction_category_is_web?(txn.category)
-
-          if (nested_is_web_category == txn_is_web_category)
-            # first child to finish wins
-            txn.name_from_child ||= nested_frame.name
-          end
-
           nested_name = nested_transaction_name(nested_frame.name)
 
           if nested_name.start_with?(MIDDLEWARE_PREFIX)
@@ -195,6 +182,88 @@ module NewRelic
         end
       end
 
+      # Indicate that you don't want to keep the currently saved transaction
+      # information
+      def self.abort_transaction! #THREAD_LOCAL_ACCESS
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.abort_transaction!(state) if txn
+      end
+
+      # If we have an active transaction, notice the error and increment the error metric.
+      # Options:
+      # * <tt>:request</tt> => Request object to get the uri and referer
+      # * <tt>:uri</tt> => The request path, minus any request params or query string.
+      # * <tt>:referer</tt> => The URI of the referer
+      # * <tt>:metric</tt> => The metric name associated with the transaction
+      # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+      # * <tt>:custom_params</tt> => Custom parameters
+      # Anything left over is treated as custom params
+
+      def self.notice_error(e, options={}) #THREAD_LOCAL_ACCESS
+        options = extract_request_options(options)
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        if txn
+          txn.notice_error(e, options)
+        else
+          NewRelic::Agent.instance.error_collector.notice_error(e, options)
+        end
+      end
+
+      def self.extract_request_options(options)
+        req = options.delete(:request)
+        if req
+          options[:uri]     = uri_from_request(req)
+          options[:referer] = referer_from_request(req)
+        end
+        options
+      end
+
+      # Returns truthy if the current in-progress transaction is considered a
+      # a web transaction (as opposed to, e.g., a background transaction).
+      #
+      # @api public
+      #
+      def self.recording_web_transaction? #THREAD_LOCAL_ACCESS
+        txn = tl_current
+        txn && txn.recording_web_transaction?
+      end
+
+      # Make a safe attempt to get the referer from a request object, generally successful when
+      # it's a Rack request.
+      def self.referer_from_request(req)
+        if req && req.respond_to?(:referer)
+          req.referer.to_s.split('?').first
+        end
+      end
+
+      # Make a safe attempt to get the URI, without the host and query string.
+      def self.uri_from_request(req)
+        approximate_uri = case
+                          when req.respond_to?(:fullpath   ) then req.fullpath
+                          when req.respond_to?(:path       ) then req.path
+                          when req.respond_to?(:request_uri) then req.request_uri
+                          when req.respond_to?(:uri        ) then req.uri
+                          when req.respond_to?(:url        ) then req.url
+                          end
+        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
+      end
+
+
+      def self.apdex_bucket(duration, failed, apdex_t)
+        case
+        when failed
+          :apdex_f
+        when duration <= apdex_t
+          :apdex_s
+        when duration <= 4 * apdex_t
+          :apdex_t
+        else
+          :apdex_f
+        end
+      end
+
       @@java_classes_loaded = false
 
       if defined? JRuby
@@ -207,16 +276,13 @@ module NewRelic
         end
       end
 
-      attr_reader :frame_stack, :cat_path_hashes
-      attr_accessor :http_response_code
-
       def initialize(category, options)
         @frame_stack = []
+        @has_children = false
 
-        @default_name    = Helper.correctly_encoded(options[:transaction_name])
-        @name_from_child = nil
-        @name_from_api   = nil
-        @frozen_name     = nil
+        self.default_name = options[:transaction_name]
+        @overridden_name    = nil
+        @frozen_name      = nil
 
         @category = category
         @start_time = Time.now
@@ -240,57 +306,67 @@ module NewRelic
         @noticed_error_ids ||= []
       end
 
-      def default_name=(name)
-        @default_name = Helper.correctly_encoded(name)
+      def overridden_name=(name)
+        @overridden_name = Helper.correctly_encoded(name)
       end
 
-      def name_from_child=(name)
-        @name_from_child = Helper.correctly_encoded(name)
+      def default_name=(name)
+        @default_name = Helper.correctly_encoded(name)
       end
 
-      def name_from_api=(name)
-        if @frozen_name
-          NewRelic::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
+      def create_nested_frame(state, category, options)
+        @has_children = true
+        if options[:filtered_params] && !options[:filtered_params].empty?
+          @filtered_params = options[:filtered_params]
         end
 
-        @name_from_api = Helper.correctly_encoded(name)
+        frame_stack.push NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
+        name_last_frame(options[:transaction_name])
+
+        set_default_transaction_name(options[:transaction_name], category)
       end
 
-      def set_default_transaction_name(name, options)
-        self.default_name = name
-        @category = options[:category] if options[:category]
+      def make_transaction_name(name, category=nil)
+        namer = Instrumentation::ControllerInstrumentation::TransactionNamer
+        "#{namer.prefix_for_category(self, category)}#{name}"
       end
 
-      def set_overriding_transaction_name(name, options)
-        self.name_from_api = name
-        set_default_transaction_name(name, options)
+      def set_default_transaction_name(name, category)
+        return log_frozen_name(name) if name_frozen?
+        if influences_transaction_name?(category)
+          self.default_name = name
+          @category = category if category
+        end
       end
 
-      def best_category
-        if frame_stack.empty?
-          category
-        else
-          frame_stack.last.category
+      def set_overriding_transaction_name(name, category)
+        return log_frozen_name(name) if name_frozen?
+        if influences_transaction_name?(category)
+          self.overridden_name = name
+          @category = category if category
         end
       end
 
-      def best_name
-        return @frozen_name   if @frozen_name
-        return @name_from_api if @name_from_api
+      def name_last_frame(name)
+        frame_stack.last.name = name
+      end
 
-        if @name_from_child
-          return @name_from_child
-        elsif !@frame_stack.empty?
-          return @frame_stack.last.name
-        end
+      def log_frozen_name(name)
+        NewRelic::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
+        nil
+      end
 
-        return @default_name if @default_name
+      def influences_transaction_name?(category)
+        !category || frame_stack.size == 1 || similar_category?(category)
+      end
 
-        NewRelic::Agent::UNKNOWN_METRIC
+      def best_name
+        @frozen_name  || @overridden_name ||
+          @default_name || NewRelic::Agent::UNKNOWN_METRIC
       end
 
       def name_set?
-        (@name_from_api || @name_from_child || @default_name) ? true : false
+        (@overridden_name || @default_name) ? true : false
       end
 
       def promoted_transaction_name(name)
@@ -324,8 +400,6 @@ module NewRelic
         @frozen_name ? true : false
       end
 
-      # Indicate that we are entering a measured controller action or task.
-      # Make sure you unwind every push with a pop call.
       def start(state)
         return if !state.is_execution_traced?
 
@@ -334,16 +408,8 @@ module NewRelic
         NewRelic::Agent.instance.events.notify(:start_transaction)
         NewRelic::Agent::BusyCalculator.dispatcher_start(start_time)
 
-        @trace_options = { :metric => true, :scoped_metric => false }
-        @expected_scope = NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, start_time.to_f)
-      end
-
-      # Indicate that you don't want to keep the currently saved transaction
-      # information
-      def self.abort_transaction! #THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        txn.abort_transaction!(state) if txn
+        frame_stack.push NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, start_time.to_f)
+        name_last_frame @default_name
       end
 
       # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
@@ -385,16 +451,17 @@ module NewRelic
         name.start_with?(MIDDLEWARE_PREFIX)
       end
 
-      def stop(state, end_time)
+      def stop(state, end_time, outermost_frame)
         return if !state.is_execution_traced?
         freeze_name_and_execute_if_not_ignored
         ignore! if user_defined_rules_ignore?
 
-        if @name_from_child
-          name = Transaction.nested_transaction_name(@default_name)
-          @trace_options[:scoped_metric] = true
+        if @has_children
+          name = Transaction.nested_transaction_name(outermost_frame.name)
+          trace_options = TRACE_OPTIONS_SCOPED
         else
           name = @frozen_name
+          trace_options = TRACE_OPTIONS_UNSCOPED
         end
 
         # These metrics are recorded here instead of in record_summary_metrics
@@ -411,8 +478,8 @@ module NewRelic
           start_time.to_f,
           name,
           summary_metrics_with_exclusive_time,
-          @expected_scope,
-          @trace_options,
+          outermost_frame,
+          trace_options,
           end_time.to_f)
 
         NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
@@ -606,37 +673,6 @@ module NewRelic
         end
       end
 
-      # If we have an active transaction, notice the error and increment the error metric.
-      # Options:
-      # * <tt>:request</tt> => Request object to get the uri and referer
-      # * <tt>:uri</tt> => The request path, minus any request params or query string.
-      # * <tt>:referer</tt> => The URI of the referer
-      # * <tt>:metric</tt> => The metric name associated with the transaction
-      # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
-      # * <tt>:custom_params</tt> => Custom parameters
-      # Anything left over is treated as custom params
-
-      def self.notice_error(e, options={}) #THREAD_LOCAL_ACCESS
-        options = extract_request_options(options)
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        if txn
-          txn.notice_error(e, options)
-        else
-          NewRelic::Agent.instance.error_collector.notice_error(e, options)
-        end
-      end
-
-      def self.extract_request_options(options)
-        req = options.delete(:request)
-        if req
-          options[:uri]     = uri_from_request(req)
-          options[:referer] = referer_from_request(req)
-        end
-        options
-      end
-
-
       # Do not call this.  Invoke the class method instead.
       def notice_error(error, options={}) # :nodoc:
         options[:uri]     ||= uri     if uri
@@ -746,56 +782,16 @@ module NewRelic
       alias_method :user_attributes, :custom_parameters
       alias_method :set_user_attributes, :add_custom_parameters
 
-      # Returns truthy if the current in-progress transaction is considered a
-      # a web transaction (as opposed to, e.g., a background transaction).
-      #
-      # @api public
-      #
-      def self.recording_web_transaction? #THREAD_LOCAL_ACCESS
-        txn = tl_current
-        txn && txn.recording_web_transaction?
-      end
-
-      def self.transaction_category_is_web?(category)
-        WEB_TRANSACTION_CATEGORIES.include?(category)
-      end
-
       def recording_web_transaction?
-        self.class.transaction_category_is_web?(@category)
-      end
-
-      # Make a safe attempt to get the referer from a request object, generally successful when
-      # it's a Rack request.
-      def self.referer_from_request(req)
-        if req && req.respond_to?(:referer)
-          req.referer.to_s.split('?').first
-        end
+        web_category?(@category)
       end
 
-      # Make a safe attempt to get the URI, without the host and query string.
-      def self.uri_from_request(req)
-        approximate_uri = case
-                          when req.respond_to?(:fullpath   ) then req.fullpath
-                          when req.respond_to?(:path       ) then req.path
-                          when req.respond_to?(:request_uri) then req.request_uri
-                          when req.respond_to?(:uri        ) then req.uri
-                          when req.respond_to?(:url        ) then req.url
-                          end
-        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
+      def web_category?(category)
+        WEB_TRANSACTION_CATEGORIES.include?(category)
       end
 
-
-      def self.apdex_bucket(duration, failed, apdex_t)
-        case
-        when failed
-          :apdex_f
-        when duration <= apdex_t
-          :apdex_s
-        when duration <= 4 * apdex_t
-          :apdex_t
-        else
-          :apdex_f
-        end
+      def similar_category?(category)
+        web_category?(@category) == web_category?(category)
       end
 
       def cpu_burn