oneapm_rpm 1.3.6 → 1.3.7.rc1

data/lib/one_apm/inst/http_clients/httpclient.rb

@@ -3,14 +3,14 @@
 LibraryDetection.defer do
   named :httpclient
 
-  HTTPCLIENT_MINIMUM_VERSION = '2.2.0'
+  OA_HTTPCLIENT_MINIMUM_VERSION = '2.2.0'
 
   depends_on do
     defined?(HTTPClient) && defined?(HTTPClient::VERSION)
   end
 
   depends_on do
-    minimum_supported_version = OneApm::VersionNumber.new(HTTPCLIENT_MINIMUM_VERSION)
+    minimum_supported_version = OneApm::VersionNumber.new(OA_HTTPCLIENT_MINIMUM_VERSION)
     current_version = OneApm::VersionNumber.new(HTTPClient::VERSION)
 
     current_version >= minimum_supported_version

data/lib/one_apm/inst/http_clients/typhoeus.rb

@@ -48,10 +48,10 @@ end
 
 module OneApm::Agent::Instrumentation::TyphoeusTracing
 
-  EARLIEST_VERSION = OneApm::VersionNumber.new("0.5.3")
+  OA_EARLIEST_VERSION = OneApm::VersionNumber.new("0.5.3")
 
   def self.is_supported_version?
-    OneApm::VersionNumber.new(Typhoeus::VERSION) >= OneApm::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
+    OneApm::VersionNumber.new(Typhoeus::VERSION) >= OneApm::Agent::Instrumentation::TyphoeusTracing::OA_EARLIEST_VERSION
   end
 
   def self.request_is_hydra_enabled?(request)

data/lib/one_apm/inst/nosql/memcache.rb

@@ -12,7 +12,7 @@ module OneApm
           !OneApm::Manager.config[:disable_memcache]
         end
 
-        METHODS = [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
+        OA_METHODS = [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
                    :prepend, :cas, :single_get, :multi_get, :single_cas, :multi_cas]
 
         def supported_methods_for(client_class, methods)
@@ -21,7 +21,7 @@ module OneApm
           end
         end
 
-        def instrument_methods(client_class, requested_methods = METHODS)
+        def instrument_methods(client_class, requested_methods = OA_METHODS)
           supported_methods_for(client_class, requested_methods).each do |method_name|
 
             visibility = OneApm::Helper.instance_method_visibility client_class, method_name
@@ -120,15 +120,15 @@ LibraryDetection.defer do
     # re-evaluate after they've done that require.
     defined?(::Dalli::Client) &&
       ::OneApm::Agent::Instrumentation::Memcache.supported_methods_for(::Dalli::Client,
-                                                                         CAS_CLIENT_METHODS).any?
+                                                                         OA_CAS_CLIENT_METHODS).any?
   end
 
-  CAS_CLIENT_METHODS = [:get_cas, :get_multi_cas, :set_cas, :replace_cas,
+  OA_CAS_CLIENT_METHODS = [:get_cas, :get_multi_cas, :set_cas, :replace_cas,
                         :delete_cas]
 
   executes do
     OneApm::Manager.logger.info 'Installing Dalli CAS Client Memcache instrumentation'
     ::OneApm::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
-                                                                    CAS_CLIENT_METHODS)
+                                                                    OA_CAS_CLIENT_METHODS)
   end
 end

data/lib/one_apm/inst/nosql/mongo2.rb

@@ -5,26 +5,26 @@ module OneApm
     module Instrumentation
       class MongoCommandSubscriber
 
-        MONGODB = 'MongoDB'.freeze
-        STARTED = 'STARTED'.freeze
-        SUCCEEDED = 'SUCCEEDED'.freeze
-        FAILED = 'FAILED'.freeze
+        OA_MONGODB = 'MongoDB'.freeze
+        OA_STARTED = 'STARTED'.freeze
+        OA_SUCCEEDED = 'SUCCEEDED'.freeze
+        OA_FAILED = 'FAILED'.freeze
 
         def started(event)
           begin
             return unless OneApm::Manager.tl_is_execution_traced?
             operations[event.operation_id] = event
           rescue Exception => e
-            log_operations_error(STARTED, e)
+            log_operations_error(OA_STARTED, e)
           end
         end
 
         def succeeded(event)
-          operator SUCCEEDED, event
+          operator OA_SUCCEEDED, event
         end
 
         def failed(event)
-          operator FAILED, event
+          operator OA_FAILED, event
         end
 
         private
@@ -35,7 +35,7 @@ module OneApm
 
         def mertircs(event)
           OneApm::Agent::Datastore::MetricHelper.metrics_for(
-            MONGODB, event.command_name, event.command.values.first
+            OA_MONGODB, event.command_name, event.command.values.first
           )
         end
 

data/lib/one_apm/inst/orm/active_record.rb

@@ -7,7 +7,7 @@ module OneApm
     module Instrumentation
       module ActiveRecord
 
-        EXPLAINER = lambda do |config, query|
+        OA_EXPLAINER = lambda do |config, query|
           connection = OneApm::Agent::Database.get_connection(config) do
             ::ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
           end
@@ -54,7 +54,7 @@ module OneApm
                 log_without_oneapm_instrumentation(*args, &block)
               ensure
                 elapsed_time = (Time.now - t0).to_f
-                OneApm::Manager.notice_sql(sql, metric, @config, elapsed_time, state, &EXPLAINER)
+                OneApm::Manager.notice_sql(sql, metric, @config, elapsed_time, state, &OA_EXPLAINER)
               end
             end
           end

data/lib/one_apm/inst/rails3/action_controller.rb

@@ -35,7 +35,7 @@ module OneApm
               if options[:file]
                 "file"
               elsif identifier.nil?
-                OneApm::Transaction::UNKNOWN_METRIC
+                OneApm::Transaction::OA_UNKNOWN_METRIC
               elsif identifier.include? '/' # this is a filepath
                 identifier.split('/')[-2..-1].join('/')
               else

data/lib/one_apm/inst/rails4/action_view_subscriber.rb

@@ -49,7 +49,7 @@ module OneApm
           def recordable?
             name[0] == '!' ||
               metric_name == 'View/text template/Rendering' ||
-              metric_name == "View/#{OneApm::Transaction::UNKNOWN_METRIC}/Partial"
+              metric_name == "View/#{OneApm::Transaction::OA_UNKNOWN_METRIC}/Partial"
           end
 
           def metric_name
@@ -75,7 +75,7 @@ module OneApm
             elsif (parts = identifier.split('/')).size > 1
               parts[-2..-1].join('/')
             else
-              OneApm::Transaction::UNKNOWN_METRIC
+              OneApm::Transaction::OA_UNKNOWN_METRIC
             end
           end
 

data/lib/one_apm/inst/rails4/active_record_subscriber.rb

@@ -9,10 +9,10 @@ module OneApm
   module Agent
     module Instrumentation
       class ActiveRecordSubscriber < EventedSubscriber
-        CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? CACHED_QUERY_NAME
+        OA_CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? OA_CACHED_QUERY_NAME
 
         def start(name, id, payload)
-          return if payload[:name] == CACHED_QUERY_NAME
+          return if payload[:name] == OA_CACHED_QUERY_NAME
           return unless OneApm::Manager.tl_is_execution_traced?
           super
         rescue => e
@@ -20,7 +20,7 @@ module OneApm
         end
 
         def finish(name, id, payload)
-          return if payload[:name] == CACHED_QUERY_NAME
+          return if payload[:name] == OA_CACHED_QUERY_NAME
           state = OneApm::TransactionState.tl_get
           return unless state.is_execution_traced?
           event = pop_event(id)

data/lib/one_apm/inst/support/queue_time.rb

@@ -4,22 +4,22 @@ module OneApm
   module Agent
     module Instrumentation
       module QueueTime
-        unless defined?(REQUEST_START_HEADER)
-          REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'.freeze
-          QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'.freeze
-          MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'.freeze
-          ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
+        unless defined?(OA_REQUEST_START_HEADER)
+          OA_REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'.freeze
+          OA_QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'.freeze
+          OA_MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'.freeze
+          OA_ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
           # any timestamps before this are thrown out and the parser
           # will try again with a larger unit (2000/1/1 UTC)
-          EARLIEST_ACCEPTABLE_TIME = Time.at(946684800)
+          OA_EARLIEST_ACCEPTABLE_TIME = Time.at(946684800)
 
-          CANDIDATE_HEADERS = [
-            REQUEST_START_HEADER,
-            QUEUE_START_HEADER,
-            MIDDLEWARE_START_HEADER
+          OA_CANDIDATE_HEADERS = [
+            OA_REQUEST_START_HEADER,
+            OA_QUEUE_START_HEADER,
+            OA_MIDDLEWARE_START_HEADER
           ].freeze
 
-          DIVISORS = [1_000_000, 1_000, 1]
+          OA_DIVISORS = [1_000_000, 1_000, 1]
         end
 
         module_function
@@ -27,7 +27,7 @@ module OneApm
         def parse_frontend_timestamp(headers, now=Time.now)
           earliest = nil
 
-          CANDIDATE_HEADERS.each do |header|
+          OA_CANDIDATE_HEADERS.each do |header|
             if headers[header]
               parsed = parse_timestamp(timestamp_string_from_header_value(headers[header]))
               if parsed && (!earliest || parsed < earliest)
@@ -54,10 +54,10 @@ module OneApm
         end
 
         def parse_timestamp(string)
-          DIVISORS.each do |divisor|
+          OA_DIVISORS.each do |divisor|
             begin
               t = Time.at(string.to_f / divisor)
-              return t if t > EARLIEST_ACCEPTABLE_TIME
+              return t if t > OA_EARLIEST_ACCEPTABLE_TIME
             rescue RangeError
               # On Ruby versions built with a 32-bit time_t, attempting to
               # instantiate a Time object in the far future raises a RangeError,

data/lib/one_apm/logger/agent_logger.rb

@@ -39,7 +39,7 @@ module OneApm
         format_and_send(:debug, msgs, &blk)
       end
 
-      NUM_LOG_ONCE_KEYS = 1000
+      OA_NUM_LOG_ONCE_KEYS = 1000
 
       def log_once(level, key, *msgs)
         # Since `already_logged` might change between calls, just grab it once
@@ -48,7 +48,7 @@ module OneApm
 
         return if logged.include?(key)
 
-        if logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
+        if logged.size >= OA_NUM_LOG_ONCE_KEYS && key.kind_of?(String)
           # The reason for preventing too many keys in `logged` is for
           # memory concerns.
           # The reason for checking the type of the key is that we always want
@@ -168,7 +168,7 @@ module OneApm
         @log.level = AgentLogger.log_level_for(OneApm::Manager.config[:log_level])
       end
 
-      LOG_LEVELS = {
+      OA_LOG_LEVELS = {
         "debug" => ::Logger::DEBUG,
         "info"  => ::Logger::INFO,
         "warn"  => ::Logger::WARN,
@@ -177,7 +177,7 @@ module OneApm
       }
 
       def self.log_level_for(level)
-        LOG_LEVELS.fetch(level.to_s.downcase, ::Logger::INFO)
+        OA_LOG_LEVELS.fetch(level.to_s.downcase, ::Logger::INFO)
       end
 
       def set_log_format!

data/lib/one_apm/metrics/metric_spec.rb

@@ -5,25 +5,25 @@ module OneApm
     attr_reader   :name, :scope
 
     # the maximum length of a metric name or metric scope
-    MAX_LENGTH = 255
-    LENGTH_RANGE = (0...MAX_LENGTH)
-    EMPTY_SCOPE = ''.freeze
+    OA_MAX_LENGTH = 255
+    OA_LENGTH_RANGE = (0...OA_MAX_LENGTH)
+    OA_EMPTY_SCOPE = ''.freeze
 
     def initialize(metric_name='', metric_scope=nil)
-      if metric_name.to_s.length > MAX_LENGTH
-        @name = metric_name.to_s[LENGTH_RANGE]
+      if metric_name.to_s.length > OA_MAX_LENGTH
+        @name = metric_name.to_s[OA_LENGTH_RANGE]
       else
         @name = metric_name.to_s
       end
 
       if metric_scope
-        if metric_scope.to_s.length > MAX_LENGTH
-          @scope = metric_scope.to_s[LENGTH_RANGE]
+        if metric_scope.to_s.length > OA_MAX_LENGTH
+          @scope = metric_scope.to_s[OA_LENGTH_RANGE]
         else
           @scope = metric_scope.to_s
         end
       else
-        @scope = EMPTY_SCOPE
+        @scope = OA_EMPTY_SCOPE
       end
     end
 
@@ -45,10 +45,10 @@ module OneApm
       OneApm::Manager.logger.warn("The sub method on metric specs is deprecated") rescue nil
       return nil if name !~ pattern &&
        (!apply_to_scope || scope.nil? || scope !~ pattern)
-      new_name = name.sub(pattern, replacement)[LENGTH_RANGE]
+      new_name = name.sub(pattern, replacement)[OA_LENGTH_RANGE]
 
       if apply_to_scope
-        new_scope = (scope && scope.sub(pattern, replacement)[LENGTH_RANGE])
+        new_scope = (scope && scope.sub(pattern, replacement)[OA_LENGTH_RANGE])
       else
         new_scope = scope
       end

data/lib/one_apm/rack/browser_monitoring.rb

@@ -5,185 +5,176 @@ require 'ipaddr'
 require 'one_apm/rack/middleware_base'
 require 'one_apm/rack/middleware_wrapper'
 
-module OneApm::Rack
-  class BrowserMonitoring < MiddlewareBase
 
-    SCAN_LIMIT = 50_000
-    ALREADY_INSTRUMENTED_KEY = "oneapm.browser_monitoring_already_instrumented"
-    REMOTE_IP = "action_dispatch.remote_ip"
+module OneApm
+  module Rack
+    class BrowserMonitoring < MiddlewareBase
 
-    CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
-    X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
+      OA_SCAN_LIMIT = 50_000
+      OA_ALREADY_INSTRUMENTED_KEY = "oneapm.browser_monitoring_already_instrumented"
+      OA_REMOTE_IP = "action_dispatch.remote_ip"
 
-    def traced_call(env)
-      result = @app.call(env)   # [status, headers, response]
+      OA_CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
+      OA_X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
 
-      js_to_inject = OneApm::Manager.browser_timing_header
-      if (js_to_inject != "") && should_instrument?(env, result[0], result[1])
-        response_string = autoinstrument_source(result[2], result[1], js_to_inject)
+      def traced_call(env)
+        result = @app.call(env)   # [status, headers, response]
 
-        env[ALREADY_INSTRUMENTED_KEY] = true
-        if response_string
-          response = Rack::Response.new(response_string, result[0], result[1])
-          response.finish
+        js_to_inject = OneApm::Manager.browser_timing_header
+        if (js_to_inject != "") && should_instrument?(env, result[0], result[1])
+          response_string = autoinstrument_source(result[2], result[1], js_to_inject)
+
+          env[OA_ALREADY_INSTRUMENTED_KEY] = true
+          if response_string
+            response = ::Rack::Response.new(response_string, result[0], result[1])
+            response.finish
+          else
+            result
+          end
         else
           result
         end
-      else
-        result
       end
-    end
 
-    def should_instrument?(env, status, headers)
-      OneApm::Manager.config[:'browser_monitoring.auto_instrument'] &&
-        status == 200 &&
-        !env[ALREADY_INSTRUMENTED_KEY] &&
-        is_html?(headers) &&
-        !is_attachment?(headers) &&
-        !is_streaming?(env) && 
-        ip_valid?(env)
-    end
+      def should_instrument?(env, status, headers)
+        OneApm::Manager.config[:'browser_monitoring.auto_instrument'] &&
+          status == 200 &&
+          !env[OA_ALREADY_INSTRUMENTED_KEY] &&
+          is_html?(headers) &&
+          !is_attachment?(headers) &&
+          !is_streaming?(env) && 
+          ip_valid?(env)
+      end
 
-    def is_html?(headers)
-      headers["Content-Type"] && headers["Content-Type"].include?("text/html")
-    end
+      def is_html?(headers)
+        headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+      end
 
-    def is_attachment?(headers)
-      headers['Content-Disposition'].to_s.include?('attachment')
-    end
+      def is_attachment?(headers)
+        headers['Content-Disposition'].to_s.include?('attachment')
+      end
 
-    def is_streaming?(env)
-      return false unless defined?(ActionController::Live)
-      env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
-    end
+      def is_streaming?(env)
+        return false unless defined?(ActionController::Live)
+        env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
+      end
 
-    def ip_valid?(env)
-      whitelist_ips = OneApm::Manager.config[:'browser_monitoring.whitelist_ips']
-      return true if whitelist_ips.empty? || env[REMOTE_IP].to_s.empty?
-      OneApm::Manager.logger.debug "Remote IP: #{env[REMOTE_IP]}"
-      begin
-        client = IPAddr.new(env[REMOTE_IP].to_s).to_i 
-        whitelist_ips.split(",").any? do |ip|
-          low_ip, high_ip = ip.split("-").map(&:strip)
-          low = IPAddr.new(low_ip).to_i
-          if high_ip
-            high = IPAddr.new(high_ip).to_i
-            (low..high) === client
-          else
-            low == client  
+      def ip_valid?(env)
+        whitelist_ips = OneApm::Manager.config[:'browser_monitoring.whitelist_ips']
+        return true if whitelist_ips.empty? || env[OA_REMOTE_IP].to_s.empty?
+        OneApm::Manager.logger.debug "Remote IP: #{env[OA_REMOTE_IP]}"
+        begin
+          client = IPAddr.new(env[OA_REMOTE_IP].to_s).to_i 
+          whitelist_ips.split(",").any? do |ip|
+            low_ip, high_ip = ip.split("-").map(&:strip)
+            low = IPAddr.new(low_ip).to_i
+            if high_ip
+              high = IPAddr.new(high_ip).to_i
+              (low..high) === client
+            else
+              low == client
+            end
           end
+        rescue => e
+          OneApm::Manager.logger.error "Configuration for browser_monitoring.whitelist_ips has problems:#{whitelist_ips}"
+          true
+        end
+      end 
+
+      def autoinstrument_source(response, headers, js_to_inject)
+        begin
+          source = gather_source(response)
+          close_old_response(response)
+          return nil unless source
+          inject_js(source, headers, js_to_inject)
+        rescue => e
+          OneApm::Manager.logger.debug "Skipping RUM instrumentation on exception.", e
+          nil
         end
-      rescue => e
-        OneApm::Manager.logger.error "Configuration for browser_monitoring.whitelist_ips has problems:#{whitelist_ips}"
-        true
-      end
-    end 
-
-    def autoinstrument_source(response, headers, js_to_inject)
-      begin
-        source = gather_source(response)
-        close_old_response(response)
-        return nil unless source
-        inject_js(source, headers, js_to_inject)
-      rescue => e
-        OneApm::Manager.logger.debug "Skipping RUM instrumentation on exception.", e
-        nil
       end
-    end
 
-    def inject_js source, headers, js_to_inject
-      position = OneApm::Manager.config[:'browser_monitoring.position']
-      insertion_index = (position.empty? || position.to_sym != :footer) ? header_index(source) : footer_index(source)
-      if insertion_index
-        source = source[0...insertion_index] \
-          << js_to_inject \
-          << source[insertion_index..-1]
-        if headers['Content-Length']
-          headers['Content-Length'] = calculate_content_length(source).to_s
+      def inject_js source, headers, js_to_inject
+        position = OneApm::Manager.config[:'browser_monitoring.position']
+        insertion_index = (position.empty? || position.to_sym != :footer) ? header_index(source) : footer_index(source)
+        if insertion_index
+          source = source[0...insertion_index] \
+            << js_to_inject \
+            << source[insertion_index..-1]
+          if headers['Content-Length']
+            headers['Content-Length'] = calculate_content_length(source).to_s
+          end
+        else
+          OneApm::Manager.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
         end
-      else
-        OneApm::Manager.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
+        source
       end
-      source
-    end
 
-    def header_index source
-      beginning_of_source = source[0..SCAN_LIMIT]
-      if body_start = find_body_start(beginning_of_source)
-        meta_tag_positions = [
-          find_x_ua_compatible_position(beginning_of_source),
-          find_charset_position(beginning_of_source)
-        ].compact
 
-        if !meta_tag_positions.empty?
-          insertion_index = meta_tag_positions.max
+      def header_index source
+        beginning_of_source = source[0..OA_SCAN_LIMIT]
+        if body_start = find_body_start(beginning_of_source)
+          meta_tag_positions = [
+            find_x_ua_compatible_position(beginning_of_source),
+            find_charset_position(beginning_of_source)
+          ].compact
+
+            if !meta_tag_positions.empty?
+              insertion_index = meta_tag_positions.max
+            else
+              insertion_index = find_end_of_head_open(beginning_of_source) || body_start
+            end
+          insertion_index
         else
-          insertion_index = find_end_of_head_open(beginning_of_source) || body_start
+          msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{OA_SCAN_LIMIT} bytes of document."
+          OneApm::Manager.logger.log_once(:warn, :rum_insertion_failure, msg)
+          OneApm::Manager.logger.debug(msg)
+          nil
         end
-        insertion_index
-      else
-        msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
-        OneApm::Manager.logger.log_once(:warn, :rum_insertion_failure, msg)
-        OneApm::Manager.logger.debug(msg)
-        nil
       end
-    end
 
-    def footer_index source
-      if body_end = find_body_end(source)
-        body_end
-      else
-        msg = "Skipping RUM instrumentation. Unable to find </body> tag from document."
-        OneApm::Manager.logger.log_once(:warn, :rum_insertion_failure, msg)
-        OneApm::Manager.logger.debug(msg)
-        nil
+      def footer_index source
+        if body_end = find_body_end(source)
+          body_end
+        else
+          msg = "Skipping RUM instrumentation. Unable to find </body> tag from document."
+          OneApm::Manager.logger.log_once(:warn, :rum_insertion_failure, msg)
+          OneApm::Manager.logger.debug(msg)
+          nil
+        end
       end
-    end
 
-    def gather_source(response)
-      source = nil
-      response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
-      source
-    end
-
-    # Per "The Response > The Body" section of Rack spec, we should close
-    # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
-    def close_old_response(response)
-      if response.respond_to?(:close)
-        response.close
+      def find_body_start(beginning_of_source)
+        beginning_of_source.index("<body")
       end
-    end
 
-    def find_body_start(beginning_of_source)
-      beginning_of_source.index("<body")
-    end
+      def find_body_end source
+        source.rindex("</body>")
+      end
 
-    def find_body_end source
-      source.rindex("</body>")
-    end
 
-    def find_x_ua_compatible_position(beginning_of_source)
-      match = X_UA_COMPATIBLE_RE.match(beginning_of_source)
-      match.end(0) if match
-    end
+      def find_x_ua_compatible_position(beginning_of_source)
+        match = OA_X_UA_COMPATIBLE_RE.match(beginning_of_source)
+        match.end(0) if match
+      end
 
-    def find_charset_position(beginning_of_source)
-      match = CHARSET_RE.match(beginning_of_source)
-      match.end(0) if match
-    end
+      def find_charset_position(beginning_of_source)
+        match = OA_CHARSET_RE.match(beginning_of_source)
+        match.end(0) if match
+      end
 
-    def find_end_of_head_open(beginning_of_source)
-      head_open = beginning_of_source.index("<head")
-      beginning_of_source.index(">", head_open) + 1 if head_open
-    end
+      def find_end_of_head_open(beginning_of_source)
+        head_open = beginning_of_source.index("<head")
+        beginning_of_source.index(">", head_open) + 1 if head_open
+      end
 
-    # String does not respond to 'bytesize' in 1.8.6. Fortunately String#length
-    # returns bytes rather than characters in 1.8.6 so we can use that instead.
-    def calculate_content_length(source)
-      if source.respond_to?(:bytesize)
-        source.bytesize
-      else
-        source.length
+      # String does not respond to 'bytesize' in 1.8.6. Fortunately String#length
+      # returns bytes rather than characters in 1.8.6 so we can use that instead.
+      def calculate_content_length(source)
+        if source.respond_to?(:bytesize)
+          source.bytesize
+        else
+          source.length
+        end
       end
     end
   end