appoptics_apm 4.5.2 → 4.6.0

data/lib/appoptics_apm/config.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2016 SolarWinds, LLC.
 # All rights reserved.
 
+require_relative 'support/transaction_settings'
+
 module AppOpticsAPM
   ##
   # This module exposes a nested configuration hash that can be used to
@@ -48,8 +50,7 @@ module AppOpticsAPM
         elsif File.exist?(File.join(ENV['APPOPTICS_APM_CONFIG_RUBY'], 'appoptics_apm_config.rb'))
           config_files << File.join(ENV['APPOPTICS_APM_CONFIG_RUBY'], 'appoptics_apm_config.rb')
         else
-          $stderr.puts 'Could not find the configuration file set by the APPOPTICS_APM_CONFIG_RUBY environment variable:'
-          $stderr.puts "#{ENV['APPOPTICS_APM_CONFIG_RUBY']}"
+          AppOpticsAPM.logger.warn "[appoptics_apm/config] Could not find the configuration file set by the APPOPTICS_APM_CONFIG_RUBY environment variable:  #{ENV['APPOPTICS_APM_CONFIG_RUBY']}"
         end
       end
 
@@ -60,8 +61,10 @@ module AppOpticsAPM
       return if config_files.empty?  # we use the defaults from the template in this case
 
       if config_files.size > 1
-        $stderr.puts 'Found multiple configuration files, using the first one listed:'
-        config_files.each { |path| $stderr.puts "  #{path}" }
+        AppOpticsAPM.logger.warn [
+          '[appoptics_apm/config] Multiple configuration files configured, using the first one listed: ',
+          config_files.join(', ')
+        ].join(' ')
       end
       load(config_files[0])
       check_env_vars
@@ -174,11 +177,12 @@ module AppOpticsAPM
     #
     # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
     def self.[]=(key, value)
-      @@config[key.to_sym] = value
+      key = key.to_sym
+      @@config[key] = value
 
       if key == :sampling_rate
         AppOpticsAPM.logger.warn '[appoptics_apm/config] sampling_rate is not a supported setting for AppOpticsAPM::Config.  ' \
-                         'Please use :sample_rate.'
+                                 'Please use :sample_rate.'
 
       elsif key == :sample_rate
         unless value.is_a?(Integer) || value.is_a?(Float)
@@ -202,6 +206,27 @@ module AppOpticsAPM
       elsif key == :action_blacklist
         AppOpticsAPM.logger.warn "[appoptics_apm/config] :action_blacklist has been deprecated and no longer functions."
 
+      elsif key == :dnt_regexp
+        if value.nil? || value == ''
+          @@config[:dnt_compiled] = nil
+        else
+          @@config[:dnt_compiled] =
+            Regexp.new(AppOpticsAPM::Config[:dnt_regexp], AppOpticsAPM::Config[:dnt_opts] || nil)
+        end
+
+      elsif key == :dnt_opts
+        if AppOpticsAPM::Config[:dnt_regexp] && AppOpticsAPM::Config[:dnt_regexp] != ''
+          @@config[:dnt_compiled] =
+            Regexp.new(AppOpticsAPM::Config[:dnt_regexp], AppOpticsAPM::Config[:dnt_opts] || nil)
+        end
+
+      elsif key == :transaction_settings
+        if value.is_a?(Hash)
+          AppOpticsAPM::TransactionSettings.compile_url_settings(value[:url])
+        else
+          AppOpticsAPM::TransactionSettings.reset_url_regexps
+        end
+
       elsif key == :resque
         AppOpticsAPM.logger.warn "[appoptics_apm/config] :resque config is deprecated.  It is now split into :resqueclient and :resqueworker."
         AppOpticsAPM.logger.warn "[appoptics_apm/config] Called from #{Kernel.caller[0]}"
@@ -228,6 +253,8 @@ module AppOpticsAPM
     end
     # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
+
+
     def self.method_missing(sym, *args)
       class_var_name = "@@#{sym}"
 

data/lib/appoptics_apm/inst/curb.rb

@@ -291,6 +291,7 @@ module AppOpticsAPM
         # If we're not tracing or we're already tracing curb, just do a fast return.
         if !AppOpticsAPM.tracing? || [:curb, :curb_multi].include?(AppOpticsAPM.layer)
           self.requests.each do |request|
+            request = request[1] if request.is_a?(Array)
             unless AppOpticsAPM::API.blacklisted?(URI(request.url).hostname)
               request.headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
             end
@@ -305,6 +306,7 @@ module AppOpticsAPM
           AppOpticsAPM::API.log_entry(:curb_multi, kvs)
 
           self.requests.each do |request|
+            request = request[1] if request.is_a?(Array)
             unless AppOpticsAPM::API.blacklisted?(URI(request.url).hostname)
               request.headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
             end

data/lib/appoptics_apm/inst/rack.rb

@@ -17,7 +17,7 @@ if AppOpticsAPM.loaded
     # 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)
+    # and act accordingly.
     #
     class Rack
       attr_reader :app
@@ -27,17 +27,37 @@ if AppOpticsAPM.loaded
       end
 
       def call(env)
+        incoming = AppOpticsAPM::Context.isValid
+
         # 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.
-        return call_app(env) if AppOpticsAPM.tracing? && AppOpticsAPM.layer == :rack
+        # of rack middleware. We want to avoid tracing rack more than once
+        return @app.call(env) if AppOpticsAPM.tracing? && AppOpticsAPM.layer == :rack
 
-        # if we already have a context, we don't want to send metrics in the end
-        return sampling_call(env) if AppOpticsAPM::Context.isValid
+        AppOpticsAPM.transaction_name = nil
 
-        # else we also send metrics
-        metrics_sampling_call(env)
+        url = env['PATH_INFO']
+        xtrace = AppOpticsAPM::XTrace.valid?(env['HTTP_X_TRACE']) ? (env['HTTP_X_TRACE']) : nil
+
+        settings = AppOpticsAPM::TransactionSettings.new(url, xtrace)
+
+        # AppOpticsAPM.logger.warn "%%% FILTER: #{settings} %%%"
+
+        response =
+          propagate_xtrace(env, settings, xtrace) do
+            sample(env, settings) do
+              AppOpticsAPM::TransactionMetrics.metrics(env, settings) do
+                @app.call(env)
+              end
+            end
+          end || [500, {}, nil]
+        AppOpticsAPM::Context.clear unless incoming
+        response
+      rescue
+        AppOpticsAPM::Context.clear unless incoming
+        raise
+        # can't use ensure for Context.clearing, because the Grape middleware
+        # needs the context in case of an error, it is somewhat convoluted ...
       end
 
       def self.noop?
@@ -46,7 +66,8 @@ if AppOpticsAPM.loaded
 
       private
 
-      def collect(req, env)
+      def collect(env, settings)
+        req = ::Rack::Request.new(env)
         report_kvs = {}
 
         begin
@@ -61,7 +82,10 @@ if AppOpticsAPM.loaded
             report_kvs[:'Query-String'] = ::CGI.unescape(req.query_string) unless req.query_string.empty?
           end
 
-          report_kvs[:Backtrace]        = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:rack][:collect_backtraces]
+          report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
+          report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:rack][:collect_backtraces]
+          report_kvs[:SampleRate]        = settings.rate
+          report_kvs[:SampleSource]      = settings.source
 
           # 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')
@@ -83,96 +107,48 @@ if AppOpticsAPM.loaded
         report_kvs
       end
 
-      def call_app(env)
-        AppOpticsAPM.logger.debug "[appoptics_apm/rack] Rack skipped!"
-        @app.call(env)
-      end
+      def propagate_xtrace(env, settings, xtrace)
+        return yield unless settings.do_propagate
 
-      # in this case we have an existing context
-      def sampling_call(env)
-        req = ::Rack::Request.new(env)
-        report_kvs = {}
-        report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
-
-        AppOpticsAPM::API.trace(:rack, report_kvs) do
-          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)
-          @app.call(env)
+        if xtrace
+          xtrace_local = xtrace.dup
+          AppOpticsAPM::XTrace.unset_sampled(xtrace_local) unless settings.do_sample
+          env['HTTP_X_TRACE'] = xtrace_local
         end
-      end
-
-      def metrics_sampling_call(env)
-        start = Time.now
-        AppOpticsAPM.transaction_name = nil
-        req = ::Rack::Request.new(env)
-        req_url = req.url   # saving it here because rails3.2 overrides it when there is a 500 error
-        status = 500        # initialize with 500
-
-        report_kvs = collect(req, env)
-        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 = AppOpticsAPM::XTrace.valid?(xtrace) ? xtrace : nil
+        status, headers, response = yield
 
-        # TODO JRUBY
-        # 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
-        # AppOpticsAPM.is_continued_trace = AppOpticsAPM.has_incoming_context || AppOpticsAPM.has_xtrace_header
-
-        AppOpticsAPM::API.log_start(:rack, xtrace, report_kvs) unless AppOpticsAPM::Util.static_asset?(env['PATH_INFO'])
-
-        status, headers, response = @app.call(env)
-        confirmed_transaction_name = send_metrics(env, req, req_url, start, status)
-        xtrace = AppOpticsAPM::API.log_end(:rack, :Status => status, :TransactionName => confirmed_transaction_name)
-
-        # TODO revisit this JRUBY condition
-        # headers['X-Trace'] = xtrace if headers.is_a?(Hash) unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
-        headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+        headers ||= {}
+        headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+        headers['X-Trace'] ||= xtrace if xtrace
+        headers['X-Trace'] && AppOpticsAPM::XTrace.unset_sampled(headers['X-Trace']) unless settings.do_sample
 
         [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)
-        AppOpticsAPM::API.log_exception(:rack, e)
-        confirmed_transaction_name ||= send_metrics(env, req, req_url, start, status)
-        xtrace = AppOpticsAPM::API.log_end(:rack, :Status => status, :TransactionName => confirmed_transaction_name)
-
-        # TODO revisit this JRUBY condition
-        # headers['X-Trace'] = xtrace if headers.is_a?(Hash) unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
-        headers['X-Trace'] = xtrace if headers.is_a?(Hash)
-
-        raise
-      end
-
-
-      def send_metrics(env, req, req_url, start, status)
-        return if 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)
-        method = req.request_method
-        AppOpticsAPM::Span.createHttpSpan(transaction_name(env), req_url, domain(req), duration, status, method, error) || ''
       end
 
-      def domain(req)
-        if AppOpticsAPM::Config['transaction_name']['prepend_domain']
-          [80, 443].include?(req.port) ? req.host : "#{req.host}:#{req.port}"
-        end
-      end
-
-      def transaction_name(env)
-        if AppOpticsAPM.transaction_name
-          AppOpticsAPM.transaction_name
-        elsif env['appoptics_apm.controller'] && env['appoptics_apm.action']
-          [env['appoptics_apm.controller'], env['appoptics_apm.action']].join('.')
+      def sample(env, settings)
+        xtrace = env['HTTP_X_TRACE']
+        if settings.do_sample
+          begin
+            report_kvs = collect(env, settings)
+
+            AppOpticsAPM::API.log_start(:rack, xtrace, report_kvs, settings)
+
+            status, headers, response = yield
+
+            AppOpticsAPM::API.log_exit(:rack, { Status: status,
+                                                TransactionName: AppOpticsAPM.transaction_name })
+            [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)
+            AppOpticsAPM::API.log_exception(:rack, e)
+            AppOpticsAPM::API.log_exit(:rack, { Status: status,
+                                                TransactionName: AppOpticsAPM.transaction_name })
+            raise
+          end
+        else
+          AppOpticsAPM::API.create_nontracing_context(xtrace)
+          yield
         end
       end
 

data/lib/appoptics_apm/logger.rb

@@ -8,35 +8,37 @@ module AppOpticsAPM
     attr_accessor :logger
   end
 
-  class Logger
-    # Fatal message
-    def fatal(string, exception = nil)
-      AppOpticsAPM.logger.fatal(string) if AppOpticsAPM.logger
-    end
-
-    # Error message
-    def error(msg, exception = nil)
-      AppOpticsAPM.logger.error(string) if AppOpticsAPM.logger
-    end
-
-    # Warn message
-    def warn(msg, exception = nil)
-      AppOpticsAPM.logger.warn(string) if AppOpticsAPM.logger
-    end
-
-    # Info message
-    def info(msg, exception = nil)
-      AppOpticsAPM.logger.info(string) if AppOpticsAPM.logger
-    end
-
-    # Debug message
-    def debug(msg, exception = nil)
-      AppOpticsAPM.logger.debug(string) if AppOpticsAPM.logger
-    end
-
-  end
+  # TODO ME currently unused, keeping it around for xtrace logging epic
+  # class Logger
+  #   # Fatal message
+  #   def fatal(msg, exception = nil)
+  #     AppOpticsAPM.logger.fatal(msg) if AppOpticsAPM.logger
+  #   end
+  #
+  #   # Error message
+  #   def error(msg, exception = nil)
+  #     AppOpticsAPM.logger.error(msg) if AppOpticsAPM.logger
+  #   end
+  #
+  #   # Warn message
+  #   def warn(msg, exception = nil)
+  #     AppOpticsAPM.logger.warn(msg) if AppOpticsAPM.logger
+  #   end
+  #
+  #   # Info message
+  #   def info(msg, exception = nil)
+  #     AppOpticsAPM.logger.info(msg) if AppOpticsAPM.logger
+  #   end
+  #
+  #   # Debug message
+  #   def debug(msg, exception = nil)
+  #     AppOpticsAPM.logger.debug(msg) if AppOpticsAPM.logger
+  #   end
+  #
+  # end
 end
 
+# Using the currently defined Logger, e.g. the Rails logger
 AppOpticsAPM.logger = Logger.new(STDERR)
 # set log level to INFO to be consistent with the c-lib, DEBUG would be default
 AppOpticsAPM.logger.level = Logger::INFO

data/lib/appoptics_apm/sdk/tracing.rb

@@ -187,6 +187,7 @@ module AppOpticsAPM
 
         # AppOpticsAPM::Event.startTrace creates an Event without an Edge
         exit_evt = AppOpticsAPM::Event.startTrace(AppOpticsAPM::Context.get)
+
         result = begin
           AppOpticsAPM::API.send_metrics(span, opts) do
             target['X-Trace'] = AppOpticsAPM::EventUtil.metadataString(exit_evt)

data/lib/appoptics_apm/support/transaction_metrics.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2018 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  ##
+  # This module sends the duration of the call and
+  # sets the transaction_name
+  #
+  module TransactionMetrics
+    class << self
+
+      ##
+      # sends the duration of the call and
+      # sets the transaction_name
+      def metrics(env, settings)
+        if settings.do_metrics
+          req = ::Rack::Request.new(env)
+          url = req.url   # saving it here because rails3.2 overrides it when there is a 500 error
+          start = Time.now
+
+          begin
+            status, headers, response = yield
+
+            AppOpticsAPM.transaction_name = send_metrics(env, req, url, start, status)
+          rescue
+            AppOpticsAPM.transaction_name = send_metrics(env, req, url, start, status || '500')
+            raise
+          end
+        else
+          status, headers, response = yield
+          AppOpticsAPM.transaction_name = "#{domain(req)}#{transaction_name(env)}" if settings.do_sample
+        end
+
+        [status, headers, response]
+      end
+
+      private
+
+      def send_metrics(env, req, url, start, status)
+        name = transaction_name(env)
+
+        status = status.to_i
+        error = status.between?(500,599) ? 1 : 0
+        duration =(1000 * 1000 * (Time.now - start)).round(0)
+        method = req.request_method
+        # AppOpticsAPM.logger.warn "%%% Sending metrics: #{name}, #{url}, #{status} %%%"
+        AppOpticsAPM::Span.createHttpSpan(name, url, domain(req), duration, status, method, error) || ''
+      end
+
+      def domain(req)
+        if AppOpticsAPM::Config['transaction_name']['prepend_domain']
+          [80, 443].include?(req.port) ? req.host : "#{req.host}:#{req.port}"
+        end
+      end
+
+      def transaction_name(env)
+        return AppOpticsAPM.transaction_name  if AppOpticsAPM.transaction_name
+
+        if env['appoptics_apm.controller'] && env['appoptics_apm.action']
+          [env['appoptics_apm.controller'], env['appoptics_apm.action']].join('.')
+        end
+      end
+
+    end
+  end
+end

data/lib/appoptics_apm/support/transaction_settings.rb

@@ -0,0 +1,186 @@
+# Copyright (c) 2018 SolarWinds, LLC.
+# All rights reserved.
+#
+
+AO_TRACING_ENABLED = 1
+AO_TRACING_DISABLED = 0
+AO_TRACING_UNSET = -1
+
+AO_TRACING_DECISIONS_TRACING_DISABLED = -2
+AO_TRACING_DECISIONS_XTRACE_NOT_SAMPLED = -1
+AO_TRACING_DECISIONS_OK = 0
+AO_TRACING_DECISIONS_NULL_OUT = 1
+AO_TRACING_DECISIONS_NO_CONFIG = 2
+AO_TRACING_DECISIONS_REPORTER_NOT_READY = 3
+AO_TRACING_DECISIONS_NO_VALID_SETTINGS = 4
+AO_TRACING_DECISIONS_QUEUE_FULL = 5
+
+module AppOpticsAPM
+  ##
+  # This module helps with setting up the filters and applying them
+  #
+  class TransactionSettings
+
+    attr_accessor :do_metrics, :do_sample
+    attr_reader   :do_propagate, :rate, :source
+
+    def initialize(url = nil, xtrace = '')
+      @do_metrics = false
+      @do_sample = false
+      @do_propagate = true
+      tracing_mode = AO_TRACING_ENABLED
+
+      if AppOpticsAPM::Context.isValid
+        @do_sample = AppOpticsAPM.tracing?
+        return
+      end
+
+      if url && asset?(url)
+        @do_propagate = false
+        return
+      end
+
+      if AppOpticsAPM.tracing_disabled? && !tracing_enabled?(url) ||
+        tracing_disabled?(url)
+        tracing_mode = AO_TRACING_DISABLED
+      end
+
+      args = [xtrace || '']
+      args << tracing_mode
+      args << AppOpticsAPM::Config[:sample_rate] if AppOpticsAPM::Config[:sample_rate]&. >= 0
+
+      metrics, sample, @rate, @source, return_code = AppOpticsAPM::Context.getDecisions(*args)
+
+      puts "return_code class: #{return_code.class}" unless return_code.is_a? Integer
+      if return_code > AO_TRACING_DECISIONS_OK
+        AppOpticsAPM.logger.warn "[appoptics-apm/sample] Problem getting the sampling decisions, code: #{return_code}"
+      end
+
+      @do_metrics = metrics > 0
+      @do_sample = sample > 0
+    end
+
+    def to_s
+      "do_propagate: #{do_propagate}, do_sample: #{do_sample}, do_metrics: #{do_metrics} rate: #{rate}, source: #{source}"
+    end
+
+    private
+    ##
+    # tracing_enabled?
+    #
+    # Given a path, this method determines whether it matches any of the
+    # regexps to exclude it from metrics and traces
+    #
+    def tracing_enabled?(url)
+      return false unless AppOpticsAPM::Config[:url_enabled_regexps].is_a? Array
+      # once we only support Ruby >= 2.4.0 use `match?` instead of `=~`
+      return AppOpticsAPM::Config[:url_enabled_regexps].any? { |regex| regex =~ url }
+    rescue => e
+      AppOpticsAPM.logger.warn "[AppOpticsAPM/filter] Could not apply :enabled filter to path. #{e.inspect}"
+      true
+    end
+
+    ##
+    # tracing_disabled?
+    #
+    # Given a path, this method determines whether it matches any of the
+    # regexps to exclude it from metrics and traces
+    #
+    def tracing_disabled?(url)
+      return false unless AppOpticsAPM::Config[:url_disabled_regexps].is_a? Array
+      # once we only support Ruby >= 2.4.0 use `match?` instead of `=~`
+      return AppOpticsAPM::Config[:url_disabled_regexps].any? { |regex| regex =~ url }
+    rescue => e
+      AppOpticsAPM.logger.warn "[AppOpticsAPM/filter] Could not apply :disabled filter to path. #{e.inspect}"
+      false
+    end
+
+    ##
+    # asset?
+    #
+    # Given a path, this method determines whether it is a static asset
+    #
+    def asset?(path)
+      return false unless AppOpticsAPM::Config[:dnt_compiled]
+      # once we only support Ruby >= 2.4.0 use `match?` instead of `=~`
+      return AppOpticsAPM::Config[:dnt_compiled] =~ path
+    rescue => e
+      AppOpticsAPM.logger.warn "[AppOpticsAPM/filter] Could not apply do-not-trace filter to path. #{e.inspect}"
+      false
+    end
+
+    public
+
+    class << self
+
+      def asset?(path)
+        return false unless AppOpticsAPM::Config[:dnt_compiled]
+        # once we only support Ruby >= 2.4.0 use `match?` instead of `=~`
+        return AppOpticsAPM::Config[:dnt_compiled] =~ path
+      rescue => e
+        AppOpticsAPM.logger.warn "[AppOpticsAPM/filter] Could not apply do-not-trace filter to path. #{e.inspect}"
+        false
+      end
+
+
+      def compile_url_settings(settings)
+        if !settings.is_a?(Array) || settings.empty?
+          reset_url_regexps
+          return
+        end
+
+        # `tracing: disabled` is the default
+        disabled = settings.select { |v| !v.has_key?(:tracing) || v[:tracing] == :disabled }
+        enabled = settings.select { |v| v[:tracing] == :enabled }
+
+        AppOpticsAPM::Config[:url_enabled_regexps] = compile_regexp(enabled)
+        AppOpticsAPM::Config[:url_disabled_regexps] = compile_regexp(disabled)
+      end
+
+      def compile_regexp(settings)
+        regexp_regexp     = compile_url_settings_regexp(settings)
+        extensions_regexp = compile_url_settings_extensions(settings)
+
+        regexps = [regexp_regexp, extensions_regexp].flatten.compact
+
+        regexps.empty? ? nil : regexps
+      end
+
+      def compile_url_settings_regexp(value)
+        regexps = value.select do |v|
+          v.key?(:regexp) &&
+            !(v[:regexp].is_a?(String) && v[:regexp].empty?) &&
+            !(v[:regexp].is_a?(Regexp) && v[:regexp].inspect == '//')
+        end
+
+        regexps.map! do |v|
+          begin
+            v[:regexp].is_a?(String) ? Regexp.new(v[:regexp], v[:opts]) : Regexp.new(v[:regexp])
+          rescue
+            AppOpticsAPM.logger.warn "[appoptics_apm/config] Problem compiling transaction_settings item #{v}, will ignore."
+            nil
+          end
+        end
+        regexps.keep_if { |v| !v.nil?}
+        regexps.empty? ? nil : regexps
+      end
+
+      def compile_url_settings_extensions(value)
+        extensions = value.select do |v|
+          v.key?(:extensions) &&
+            v[:extensions].is_a?(Array) &&
+            !v[:extensions].empty?
+        end
+        extensions = extensions.map { |v| v[:extensions] }.flatten
+        extensions.keep_if { |v| v.is_a?(String)}
+
+        extensions.empty? ? nil : Regexp.new("(#{Regexp.union(extensions).source})(\\?.+){0,1}$")
+      end
+
+      def reset_url_regexps
+        AppOpticsAPM::Config[:url_enabled_regexps] = nil
+        AppOpticsAPM::Config[:url_disabled_regexps] = nil
+      end
+    end
+  end
+end