newrelic_rpm 6.8.0.360 → 9.2.2

data/lib/new_relic/agent/{cross_app_tracing.rb → distributed_tracing/cross_app_tracing.rb}

@@ -1,7 +1,6 @@
-# -*- ruby -*-
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'json'
 
@@ -9,27 +8,26 @@ module NewRelic
   module Agent
     module CrossAppTracing
       # The cross app response header for "outgoing" calls
-      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
 
       # The cross app id header for "outgoing" calls
-      NR_ID_HEADER = 'X-NewRelic-ID'.freeze
+      NR_ID_HEADER = 'X-NewRelic-ID'
 
       # The cross app transaction header for "outgoing" calls
-      NR_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
 
-      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'.freeze
-      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'.freeze
-      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
+      NR_MESSAGE_BROKER_ID_HEADER = 'NewRelicID'
+      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'
+      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'
 
       attr_accessor :is_cross_app_caller, :cross_app_payload, :cat_path_hashes
 
       def is_cross_app_caller?
-        @is_cross_app_caller = false unless defined? @is_cross_app_caller
-        @is_cross_app_caller
+        @is_cross_app_caller ||= false
       end
 
       def is_cross_app_callee?
-        cross_app_payload != nil
+        !cross_app_payload.nil?
       end
 
       def is_cross_app?
@@ -37,28 +35,66 @@ module NewRelic
       end
 
       def cat_trip_id
-        cross_app_payload && cross_app_payload.referring_trip_id || guid
+        cross_app_payload&.referring_trip_id || transaction.guid
+      end
+
+      def cross_app_monitor
+        NewRelic::Agent.instance.monitors.cross_app_monitor
       end
 
       def cat_path_hash
         referring_path_hash = cat_referring_path_hash || '0'
         seed = referring_path_hash.to_i(16)
-        result = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
+        result = cross_app_monitor.path_hash(transaction.best_name, seed)
         record_cat_path_hash(result)
         result
       end
 
-      def add_message_cat_headers headers
-        self.is_cross_app_caller = true
-        CrossAppTracing.insert_message_headers headers,
-                                               guid,
-                                               cat_trip_id,
-                                               cat_path_hash,
-                                               raw_synthetics_header
+      def insert_cross_app_header(headers)
+        return unless CrossAppTracing.cross_app_enabled?
+
+        @is_cross_app_caller = true
+        txn_guid = transaction.guid
+        trip_id = cat_trip_id
+        path_hash = cat_path_hash
+
+        insert_request_headers(headers, txn_guid, trip_id, path_hash)
+      end
+
+      def add_message_cat_headers(headers)
+        return unless CrossAppTracing.cross_app_enabled?
+
+        @is_cross_app_caller = true
+        insert_message_headers(headers,
+          transaction.guid,
+          cat_trip_id,
+          cat_path_hash,
+          transaction.raw_synthetics_header)
+      end
+
+      def record_cross_app_metrics
+        if (id = cross_app_payload&.id)
+          app_time_in_seconds = [
+            Process.clock_gettime(Process::CLOCK_REALTIME) - transaction.start_time,
+            0.0
+          ].max
+          NewRelic::Agent.record_metric("ClientApplication/#{id}/all", app_time_in_seconds)
+        end
+      end
+
+      def assign_cross_app_intrinsics
+        transaction.attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
+        transaction.attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
       end
 
       private
 
+      def insert_message_headers(headers, txn_guid, trip_id, path_hash, synthetics_header)
+        headers[NR_MESSAGE_BROKER_ID_HEADER] = obfuscator.obfuscate(Agent.config[:cross_process_id])
+        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
+        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
+      end
+
       def record_cat_path_hash(hash)
         @cat_path_hashes ||= []
         if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
@@ -67,23 +103,25 @@ module NewRelic
       end
 
       def cat_referring_path_hash
-        cross_app_payload && cross_app_payload.referring_path_hash
+        cross_app_payload&.referring_path_hash
       end
 
       def append_cat_info(payload)
-        if (referring_guid = cross_app_payload && cross_app_payload.referring_guid)
+        if (referring_guid = cross_app_payload&.referring_guid)
           payload[:referring_transaction_guid] = referring_guid
         end
 
-        return unless include_guid?
-        payload[:guid] = guid
+        return unless transaction.include_guid?
+
+        payload[:guid] = transaction.guid
 
         return unless is_cross_app?
-        trip_id             = cat_trip_id
-        path_hash           = cat_path_hash
+
+        trip_id = cat_trip_id
+        path_hash = cat_path_hash
         referring_path_hash = cat_referring_path_hash
 
-        payload[:cat_trip_id]             = trip_id             if trip_id
+        payload[:cat_trip_id] = trip_id if trip_id
         payload[:cat_referring_path_hash] = referring_path_hash if referring_path_hash
 
         if path_hash
@@ -96,20 +134,9 @@ module NewRelic
         end
       end
 
-      def assign_cross_app_intrinsics
-        attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
-        attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
-      end
-
-      def record_cross_app_metrics
-        if (id = cross_app_payload && cross_app_payload.id)
-          app_time_in_seconds = [Time.now.to_f - @start_time.to_f, 0.0].max
-          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
-        end
-      end
-
       ###############
       module_function
+
       ###############
 
       def cross_app_enabled?
@@ -119,38 +146,37 @@ module NewRelic
       end
 
       def valid_cross_process_id?
-        if NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
+        if Agent.config[:cross_process_id] && Agent.config[:cross_process_id].length > 0
           true
         else
-          NewRelic::Agent.logger.debug "No cross_process_id configured"
+          NewRelic::Agent.logger.debug('No cross_process_id configured')
           false
         end
       end
 
       def valid_encoding_key?
-        if NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
+        if Agent.config[:encoding_key] && Agent.config[:encoding_key].length > 0
           true
         else
-          NewRelic::Agent.logger.debug "No encoding_key set"
+          NewRelic::Agent.logger.debug('No encoding_key set')
           false
         end
       end
 
       def cross_application_tracer_enabled?
         !NewRelic::Agent.config[:"distributed_tracing.enabled"] &&
-          (NewRelic::Agent.config[:"cross_application_tracer.enabled"] ||
-           NewRelic::Agent.config[:cross_application_tracing])
+          NewRelic::Agent.config[:"cross_application_tracer.enabled"]
       end
 
       def obfuscator
-        @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(Agent.config[:encoding_key])
       end
 
-      def insert_request_headers request, txn_guid, trip_id, path_hash
+      def insert_request_headers(request, txn_guid, trip_id, path_hash)
         cross_app_id = NewRelic::Agent.config[:cross_process_id]
-        txn_data  = ::JSON.dump([txn_guid, false, trip_id, path_hash])
+        txn_data = ::JSON.dump([txn_guid, false, trip_id, path_hash])
 
-        request[NR_ID_HEADER]  = obfuscator.obfuscate(cross_app_id)
+        request[NR_ID_HEADER] = obfuscator.obfuscate(cross_app_id)
         request[NR_TXN_HEADER] = obfuscator.obfuscate(txn_data)
       end
 
@@ -158,7 +184,7 @@ module NewRelic
         if !!response[NR_APPDATA_HEADER]
           true
         else
-          NewRelic::Agent.logger.debug "No #{NR_APPDATA_HEADER} header"
+          NewRelic::Agent.logger.debug("No #{NR_APPDATA_HEADER} header")
           false
         end
       end
@@ -188,44 +214,38 @@ module NewRelic
         !!(xp_id =~ /\A\d+#\d+\z/)
       end
 
-      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
-        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(NewRelic::Agent.config[:cross_process_id])
-        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
-        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
-      end
-
-      def message_has_crossapp_request_header? headers
+      def message_has_crossapp_request_header?(headers)
         !!headers[NR_MESSAGE_BROKER_ID_HEADER]
       end
 
-      def reject_messaging_cat_headers headers
-        headers.reject {|k,_| k == NR_MESSAGE_BROKER_ID_HEADER || k == NR_MESSAGE_BROKER_TXN_HEADER}
+      def reject_messaging_cat_headers(headers)
+        headers.reject { |k, _| k == NR_MESSAGE_BROKER_ID_HEADER || k == NR_MESSAGE_BROKER_TXN_HEADER }
       end
 
-      def trusts? id
+      def trusts?(id)
         split_id = id.match(/(\d+)#\d+/)
         return false if split_id.nil?
 
-        NewRelic::Agent.config[:trusted_account_ids].include? split_id.captures.first.to_i
+        NewRelic::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
       end
 
-      def trusted_valid_cross_app_id? id
+      def trusted_valid_cross_app_id?(id)
         valid_cross_app_id?(id) && trusts?(id)
       end
 
       # From inbound request headers
-      def assign_intrinsic_transaction_attributes state
+      def assign_intrinsic_transaction_attributes(state)
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
-        return unless (transaction       = state.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        return unless (txn = state.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
-        if (cross_app_id = cross_app_payload.id)
-          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
+        if (cross_app_id = payload.id)
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
         end
 
-        if (referring_guid = cross_app_payload.referring_guid)
-          transaction.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
+        if (referring_guid = payload.referring_guid)
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
         end
       end
     end

data/lib/new_relic/agent/distributed_tracing/distributed_trace_attributes.rb

@@ -0,0 +1,84 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTraceAttributes
+      extend self
+
+      # Intrinsic Keys
+      INTRINSIC_KEYS = [
+        PARENT_TYPE_KEY = 'parent.type',
+        PARENT_APP_KEY = 'parent.app',
+        PARENT_ACCOUNT_ID_KEY = 'parent.account',
+        PARENT_TRANSPORT_TYPE_KEY = 'parent.transportType',
+        PARENT_TRANSPORT_DURATION_KEY = 'parent.transportDuration',
+        GUID_KEY = 'guid',
+        TRACE_ID_KEY = 'traceId',
+        PARENT_TRANSACTION_ID_KEY = 'parentId',
+        PARENT_SPAN_ID_KEY = 'parentSpanId',
+        SAMPLED_KEY = 'sampled'
+      ].freeze
+
+      # This method extracts intrinsics from the transaction_payload and
+      # inserts them into the specified destination.
+      def copy_to_hash(transaction_payload, destination)
+        return unless enabled?
+
+        INTRINSIC_KEYS.each do |key|
+          value = transaction_payload[key]
+          destination[key] = value unless value.nil?
+        end
+      end
+
+      # This method extracts intrinsics from the transaction_payload and
+      # inserts them as intrinsics in the specified transaction_attributes
+      def copy_to_attributes(transaction_payload, destination)
+        return unless enabled?
+
+        INTRINSIC_KEYS.each do |key|
+          next unless transaction_payload.key?(key)
+
+          destination.add_intrinsic_attribute(key, transaction_payload[key])
+        end
+      end
+
+      # This method takes all distributed tracing intrinsics from the transaction
+      # and the trace_payload, and populates them into the destination
+      def copy_from_transaction(transaction, trace_payload, destination)
+        destination[GUID_KEY] = transaction.guid
+        destination[SAMPLED_KEY] = transaction.sampled?
+        destination[TRACE_ID_KEY] = transaction.trace_id
+
+        if transaction.parent_span_id
+          destination[PARENT_SPAN_ID_KEY] = transaction.parent_span_id
+        end
+
+        copy_parent_attributes(transaction, trace_payload, destination)
+      end
+
+      def copy_parent_attributes(transaction, trace_payload, destination)
+        transport_type = transaction.distributed_tracer.caller_transport_type
+        destination[PARENT_TRANSPORT_TYPE_KEY] = DistributedTraceTransportType.from(transport_type)
+
+        if trace_payload
+          destination[PARENT_TYPE_KEY] = trace_payload.parent_type
+          destination[PARENT_APP_KEY] = trace_payload.parent_app_id
+          destination[PARENT_ACCOUNT_ID_KEY] = trace_payload.parent_account_id
+          destination[PARENT_TRANSPORT_DURATION_KEY] = transaction.calculate_transport_duration(trace_payload)
+
+          if parent_transaction_id = transaction.distributed_tracer.parent_transaction_id
+            destination[PARENT_TRANSACTION_ID_KEY] = parent_transaction_id
+          end
+        end
+      end
+
+      private
+
+      def enabled?
+        return Agent.config[:'distributed_tracing.enabled']
+      end
+    end
+  end
+end

data/lib/new_relic/agent/distributed_tracing/distributed_trace_metrics.rb

@@ -0,0 +1,75 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTraceMetrics
+      extend self
+
+      ALL_SUFFIX = 'all'
+      ALL_WEB_SUFFIX = 'allWeb'
+      ALL_OTHER_SUFFIX = 'allOther'
+
+      UNKNOWN_CALLER_PREFIX = '%s/Unknown/Unknown/Unknown/%s'
+
+      def transaction_type_suffix
+        if Transaction.recording_web_transaction?
+          ALL_WEB_SUFFIX
+        else
+          ALL_OTHER_SUFFIX
+        end
+      end
+
+      def record_metrics_for_transaction(transaction)
+        return unless Agent.config[:'distributed_tracing.enabled']
+
+        dt = transaction.distributed_tracer
+        payload = dt.distributed_trace_payload || dt.trace_state_payload
+
+        record_caller_by_duration_metrics(transaction, payload)
+        record_transport_duration_metrics(transaction, payload)
+        record_errors_by_caller_metrics(transaction, payload)
+      end
+
+      def prefix_for_metric(name, transaction, payload)
+        if payload
+          "#{name}/" \
+          "#{payload.parent_type}/" \
+          "#{payload.parent_account_id}/" \
+          "#{payload.parent_app_id}/" \
+          "#{transaction.distributed_tracer.caller_transport_type}"
+        else
+          UNKNOWN_CALLER_PREFIX % [name, transaction.distributed_tracer.caller_transport_type]
+        end
+      end
+
+      def record_caller_by_duration_metrics(transaction, payload)
+        prefix = prefix_for_metric('DurationByCaller', transaction, payload)
+        record_unscoped_metric(transaction, prefix, transaction.duration)
+      end
+
+      def record_transport_duration_metrics(transaction, payload)
+        return unless payload
+
+        prefix = prefix_for_metric('TransportDuration', transaction, payload)
+        duration = transaction.calculate_transport_duration(payload)
+        record_unscoped_metric(transaction, prefix, duration)
+      end
+
+      def record_errors_by_caller_metrics(transaction, payload)
+        return unless transaction.exceptions.size > 0
+
+        prefix = prefix_for_metric('ErrorsByCaller', transaction, payload)
+        record_unscoped_metric(transaction, prefix, 1)
+      end
+
+      private
+
+      def record_unscoped_metric(transaction, prefix, duration)
+        transaction.metrics.record_unscoped("#{prefix}/#{ALL_SUFFIX}", duration)
+        transaction.metrics.record_unscoped("#{prefix}/#{transaction_type_suffix}", duration)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/distributed_tracing/distributed_trace_payload.rb

@@ -0,0 +1,163 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+
+module NewRelic
+  module Agent
+    #
+    # This class contains properties related to distributed traces.
+    # To obtain an instance, call
+    # {DistributedTracing#create_distributed_trace_payload}
+    #
+    # @api public
+    class DistributedTracePayload
+      extend Coerce
+
+      VERSION = [0, 1].freeze
+      PARENT_TYPE = 'App'
+
+      # Key names for serialization
+      VERSION_KEY = 'v'
+      DATA_KEY = 'd'
+      PARENT_TYPE_KEY = 'ty'
+      PARENT_ACCOUNT_ID_KEY = 'ac'
+      PARENT_APP_KEY = 'ap'
+      TRUSTED_ACCOUNT_KEY = 'tk'
+      ID_KEY = 'id'
+      TX_KEY = 'tx'
+      TRACE_ID_KEY = 'tr'
+      SAMPLED_KEY = 'sa'
+      TIMESTAMP_KEY = 'ti'
+      PRIORITY_KEY = 'pr'
+
+      class << self
+        def for_transaction(transaction)
+          return nil unless connected?
+
+          payload = new
+          payload.version = VERSION
+          payload.parent_type = PARENT_TYPE
+          payload.parent_account_id = Agent.config[:account_id]
+          payload.parent_app_id = Agent.config[:primary_application_id]
+
+          assign_trusted_account_key(payload, payload.parent_account_id)
+
+          payload.id = current_segment_id(transaction)
+          payload.transaction_id = transaction.guid
+          payload.timestamp = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
+          payload.trace_id = transaction.trace_id
+          payload.sampled = transaction.sampled?
+          payload.priority = transaction.priority
+
+          payload
+        end
+
+        def from_json(serialized_payload)
+          raw_payload = JSON.parse(serialized_payload)
+          return raw_payload if raw_payload.nil?
+
+          payload_data = raw_payload[DATA_KEY]
+
+          payload = new
+          payload.version = raw_payload[VERSION_KEY]
+          payload.parent_type = payload_data[PARENT_TYPE_KEY]
+          payload.parent_account_id = payload_data[PARENT_ACCOUNT_ID_KEY]
+          payload.parent_app_id = payload_data[PARENT_APP_KEY]
+          payload.trusted_account_key = payload_data[TRUSTED_ACCOUNT_KEY]
+          payload.timestamp = payload_data[TIMESTAMP_KEY]
+          payload.id = payload_data[ID_KEY]
+          payload.transaction_id = payload_data[TX_KEY]
+          payload.trace_id = payload_data[TRACE_ID_KEY]
+          payload.sampled = payload_data[SAMPLED_KEY]
+          payload.priority = payload_data[PRIORITY_KEY]
+
+          payload
+        end
+
+        def from_http_safe(http_safe_payload)
+          decoded_payload = Base64.strict_decode64(http_safe_payload)
+          from_json(decoded_payload)
+        end
+
+        def major_version_matches?(payload)
+          payload.version[0] == VERSION[0]
+        end
+
+        private
+
+        def assign_trusted_account_key(payload, account_id)
+          trusted_account_key = Agent.config[:trusted_account_key]
+
+          if account_id != trusted_account_key
+            payload.trusted_account_key = trusted_account_key
+          end
+        end
+
+        def current_segment_id(transaction)
+          if Agent.config[:'span_events.enabled'] && transaction.current_segment
+            transaction.current_segment.guid
+          end
+        end
+
+        def connected?
+          Agent.instance.connected?
+        end
+      end
+
+      attr_accessor :version,
+        :parent_type,
+        :parent_account_id,
+        :parent_app_id,
+        :trusted_account_key,
+        :id,
+        :transaction_id,
+        :trace_id,
+        :sampled,
+        :priority,
+        :timestamp
+
+      alias_method :sampled?, :sampled
+
+      # Represent this payload as a raw JSON string.
+      #
+      # @return [String] Payload translated to JSON
+      #
+      # @api public
+      def text
+        result = {
+          VERSION_KEY => version
+        }
+
+        result[DATA_KEY] = {
+          PARENT_TYPE_KEY => parent_type,
+          PARENT_ACCOUNT_ID_KEY => parent_account_id,
+          PARENT_APP_KEY => parent_app_id,
+          TX_KEY => transaction_id,
+          TRACE_ID_KEY => trace_id,
+          SAMPLED_KEY => sampled,
+          PRIORITY_KEY => priority,
+          TIMESTAMP_KEY => timestamp
+        }
+
+        result[DATA_KEY][ID_KEY] = id if id
+        result[DATA_KEY][TRUSTED_ACCOUNT_KEY] = trusted_account_key if trusted_account_key
+
+        JSON.dump(result)
+      end
+
+      # Encode this payload as a string suitable for passing via an
+      # HTTP header.
+      #
+      # @return [String] Payload translated to JSON and encoded for
+      #                  inclusion in headers
+      #
+      # @api public
+      def http_safe
+        Base64.strict_encode64(text)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/distributed_tracing/distributed_trace_transport_type.rb

@@ -0,0 +1,38 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTraceTransportType
+      extend self
+
+      ALLOWABLE_TRANSPORT_TYPES = [
+        NewRelic::UNKNOWN,
+        NewRelic::HTTP,
+        NewRelic::HTTPS,
+        'Kafka',
+        'JMS',
+        'IronMQ',
+        'AMQP',
+        'Queue',
+        'Other'
+      ].freeze
+
+      URL_SCHEMES = {
+        'http' => NewRelic::HTTP,
+        'https' => NewRelic::HTTPS
+      }.freeze
+
+      RACK_URL_SCHEME = 'rack.url_scheme'
+
+      def from(value)
+        ALLOWABLE_TRANSPORT_TYPES.include?(value) ? value : NewRelic::UNKNOWN
+      end
+
+      def for_rack_request(request)
+        URL_SCHEMES[request[RACK_URL_SCHEME]]
+      end
+    end
+  end
+end