newrelic_rpm 8.9.0 → 8.10.0

data/lib/new_relic/agent/transaction/distributed_tracer.rb

@@ -26,12 +26,12 @@ module NewRelic
           end
         end
 
-        def accept_incoming_request request, transport_type = nil
-          accept_incoming_transport_type request, transport_type
-          if trace_parent_header_present? request
-            accept_trace_context_incoming_request request
+        def accept_incoming_request(request, transport_type = nil)
+          accept_incoming_transport_type(request, transport_type)
+          if trace_parent_header_present?(request)
+            accept_trace_context_incoming_request(request)
           else
-            accept_distributed_tracing_incoming_request request
+            accept_distributed_tracing_incoming_request(request)
           end
         end
 
@@ -39,84 +39,89 @@ module NewRelic
           @caller_transport_type ||= "Unknown"
         end
 
-        def accept_transport_type_from_api value
-          @caller_transport_type = DistributedTraceTransportType.from value
+        def accept_transport_type_from_api(value)
+          @caller_transport_type = DistributedTraceTransportType.from(value)
         end
 
-        def accept_incoming_transport_type request, transport_type
+        def accept_incoming_transport_type(request, transport_type)
           if transport_type.to_s == NewRelic::EMPTY_STR
-            @caller_transport_type = DistributedTraceTransportType.for_rack_request request
+            @caller_transport_type = DistributedTraceTransportType.for_rack_request(request)
           else
-            @caller_transport_type = DistributedTraceTransportType.from transport_type
+            @caller_transport_type = DistributedTraceTransportType.from(transport_type)
           end
         end
 
-        def initialize transaction
+        def initialize(transaction)
           @transaction = transaction
         end
 
         def record_metrics
           record_cross_app_metrics
-          DistributedTraceMetrics.record_metrics_for_transaction transaction
+          DistributedTraceMetrics.record_metrics_for_transaction(transaction)
         end
 
-        def append_payload payload
-          append_cat_info payload
-          DistributedTraceAttributes.copy_from_transaction \
+        def append_payload(payload)
+          append_cat_info(payload)
+          DistributedTraceAttributes.copy_from_transaction( \
             transaction,
             trace_state_payload || distributed_trace_payload,
             payload
+          )
         end
 
-        def log_request_headers headers, direction = "OUTGOING"
-          NewRelic::Agent.logger.debug "#{direction} REQUEST HEADERS: #{headers}"
+        def log_request_headers(headers, direction = "OUTGOING")
+          NewRelic::Agent.logger.debug("#{direction} REQUEST HEADERS: #{headers}")
         end
 
-        def insert_headers headers
+        def insert_headers(headers)
           return unless NewRelic::Agent.agent.connected?
-          insert_trace_context_header headers
-          insert_distributed_trace_header headers
-          insert_cross_app_header headers
-          log_request_headers headers
+          insert_trace_context_header(headers)
+          insert_distributed_trace_header(headers)
+          insert_cross_app_header(headers)
+          log_request_headers(headers)
         end
 
-        def consume_message_headers headers, tracer_state, transport_type
-          log_request_headers headers, "INCOMING"
-          consume_message_distributed_tracing_headers headers, transport_type
-          consume_message_cross_app_tracing_headers headers, tracer_state
-          consume_message_synthetics_headers headers
+        def consume_message_headers(headers, tracer_state, transport_type)
+          log_request_headers(headers, "INCOMING")
+          consume_message_distributed_tracing_headers(headers, transport_type)
+          consume_message_cross_app_tracing_headers(headers, tracer_state)
+          consume_message_synthetics_headers(headers)
         rescue => e
-          NewRelic::Agent.logger.error "Error in consume_message_headers", e
+          NewRelic::Agent.logger.error("Error in consume_message_headers", e)
         end
 
         def assign_intrinsics
-          if Agent.config[:'distributed_tracing.enabled']
-            DistributedTraceAttributes.copy_to_attributes transaction.payload, transaction.attributes
+          if dt_enabled?
+            DistributedTraceAttributes.copy_to_attributes(transaction.payload, transaction.attributes)
           elsif is_cross_app?
             assign_cross_app_intrinsics
           end
         end
 
-        def insert_distributed_trace_header headers
-          return unless Agent.config[:'distributed_tracing.enabled']
+        def insert_distributed_trace_header(headers)
+          return unless dt_enabled?
           return if Agent.config[:'exclude_newrelic_header']
           payload = create_distributed_trace_payload
           headers[NewRelic::NEWRELIC_KEY] = payload.http_safe if payload
         end
 
-        def insert_cat_headers headers
+        def insert_cat_headers(headers)
           return unless CrossAppTracing.cross_app_enabled?
           @is_cross_app_caller = true
-          insert_message_headers headers,
+          insert_message_headers(headers,
             transaction.guid,
             cat_trip_id,
             cat_path_hash,
-            transaction.raw_synthetics_header
+            transaction.raw_synthetics_header)
         end
 
         private
 
-        def consume_message_synthetics_headers headers
+        def dt_enabled?
+          Agent.config[:'distributed_tracing.enabled']
+        end
+
+        def consume_message_synthetics_headers(headers)
           synthetics_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER]
           if synthetics_header and
               incoming_payload = ::JSON.load(deobfuscate(synthetics_header)) and
@@ -128,31 +133,31 @@ module NewRelic
             transaction.synthetics_payload = incoming_payload
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error in consume_message_synthetics_header", e
+          NewRelic::Agent.logger.error("Error in consume_message_synthetics_header", e)
         end
 
-        def consume_message_distributed_tracing_headers headers, transport_type
-          return unless Agent.config[:'distributed_tracing.enabled']
+        def consume_message_distributed_tracing_headers(headers, transport_type)
+          return unless dt_enabled?
 
-          accept_incoming_transport_type headers, transport_type
+          accept_incoming_transport_type(headers, transport_type)
 
           newrelic_trace_key = NewRelic::CANDIDATE_NEWRELIC_KEYS.detect do |key|
             headers.has_key?(key)
           end
           return unless newrelic_trace_key && (payload = headers[newrelic_trace_key])
 
-          accept_distributed_trace_payload payload
+          accept_distributed_trace_payload(payload)
         end
 
-        def consume_message_cross_app_tracing_headers headers, tracer_state
+        def consume_message_cross_app_tracing_headers(headers, tracer_state)
           return unless CrossAppTracing.cross_app_enabled?
           return unless CrossAppTracing.message_has_crossapp_request_header?(headers)
 
-          accept_cross_app_payload headers, tracer_state
-          CrossAppTracing.assign_intrinsic_transaction_attributes tracer_state
+          accept_cross_app_payload(headers, tracer_state)
+          CrossAppTracing.assign_intrinsic_transaction_attributes(tracer_state)
         end
 
-        def accept_cross_app_payload headers, tracer_state
+        def accept_cross_app_payload(headers, tracer_state)
           encoded_id = headers[CrossAppTracing::NR_MESSAGE_BROKER_ID_HEADER]
           decoded_id = encoded_id.nil? ? EMPTY_STRING : deobfuscate(encoded_id)
 
@@ -167,8 +172,8 @@ module NewRelic
           nil
         end
 
-        def deobfuscate message
-          CrossAppTracing.obfuscator.deobfuscate message
+        def deobfuscate(message)
+          CrossAppTracing.obfuscator.deobfuscate(message)
         end
       end
     end

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

@@ -36,11 +36,11 @@ module NewRelic
 
         NEWRELIC_TRACE_KEY = "HTTP_NEWRELIC"
 
-        def accept_distributed_tracing_incoming_request request
+        def accept_distributed_tracing_incoming_request(request)
           return unless Agent.config[:'distributed_tracing.enabled']
           return unless payload = request[NEWRELIC_TRACE_KEY]
 
-          accept_distributed_trace_payload payload
+          accept_distributed_trace_payload(payload)
         end
 
         def distributed_trace_payload_created?
@@ -51,16 +51,16 @@ module NewRelic
           return unless Agent.config[:'distributed_tracing.enabled']
 
           @distributed_trace_payload_created = true
-          payload = DistributedTracePayload.for_transaction transaction
-          NewRelic::Agent.increment_metric CREATE_SUCCESS_METRIC
+          payload = DistributedTracePayload.for_transaction(transaction)
+          NewRelic::Agent.increment_metric(CREATE_SUCCESS_METRIC)
           payload
         rescue => e
-          NewRelic::Agent.increment_metric CREATE_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Failed to create distributed trace payload", e
+          NewRelic::Agent.increment_metric(CREATE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to create distributed trace payload", e)
           nil
         end
 
-        def accept_distributed_trace_payload payload
+        def accept_distributed_trace_payload(payload)
           return unless Agent.config[:'distributed_tracing.enabled']
 
           return false if check_payload_ignored(payload)
@@ -72,11 +72,11 @@ module NewRelic
 
           assign_payload_and_sampling_params(payload)
 
-          NewRelic::Agent.increment_metric ACCEPT_SUCCESS_METRIC
+          NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
         rescue => e
-          NewRelic::Agent.increment_metric ACCEPT_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Failed to accept distributed trace payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to accept distributed trace payload", e)
           false
         end
 
@@ -84,10 +84,10 @@ module NewRelic
 
         def check_payload_ignored(payload)
           if distributed_trace_payload
-            NewRelic::Agent.increment_metric IGNORE_MULTIPLE_ACCEPT_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)
             return true
           elsif distributed_trace_payload_created?
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_AFTER_CREATE_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_AFTER_CREATE_METRIC)
             return true
           end
           false
@@ -96,7 +96,7 @@ module NewRelic
         def check_payload_present(payload)
           # We might be passed a Ruby `nil` object _or_ the JSON "null"
           if payload.nil? || payload == NULL_PAYLOAD
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_NULL_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_NULL_METRIC)
             return nil
           end
 
@@ -104,18 +104,18 @@ module NewRelic
         end
 
         def decode_payload(payload)
-          decoded = if payload.start_with? LBRACE
-            DistributedTracePayload.from_json payload
+          decoded = if payload.start_with?(LBRACE)
+            DistributedTracePayload.from_json(payload)
           else
-            DistributedTracePayload.from_http_safe payload
+            DistributedTracePayload.from_http_safe(payload)
           end
 
           return nil unless check_payload_present(decoded)
 
           decoded
         rescue => e
-          NewRelic::Agent.increment_metric ACCEPT_PARSE_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Error parsing distributed trace payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Error parsing distributed trace payload", e)
           nil
         end
 
@@ -131,7 +131,7 @@ module NewRelic
 
             true
           else
-            NewRelic::Agent.increment_metric ACCEPT_PARSE_EXCEPTION_METRIC
+            NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
             false
           end
         end
@@ -140,7 +140,7 @@ module NewRelic
           if DistributedTracePayload.major_version_matches?(payload)
             true
           else
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_MAJOR_VERSION_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_MAJOR_VERSION_METRIC)
             false
           end
         end
@@ -148,7 +148,7 @@ module NewRelic
         def check_trusted_account(payload)
           compare_key = payload.trusted_account_key || payload.parent_account_id
           unless compare_key == NewRelic::Agent.config[:trusted_account_key]
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC)
             return false
           end
           true

data/lib/new_relic/agent/transaction/external_request_segment.rb

@@ -22,16 +22,17 @@ module NewRelic
         EXTERNAL_ALL_OTHER = "External/allOther"
         MISSING_STATUS_CODE = "MissingHTTPStatusCode"
 
-        attr_reader :library, :uri, :procedure
-        attr_reader :http_status_code
+        attr_reader :library, :uri, :procedure, :http_status_code
+        attr_writer :record_agent_attributes
 
-        def initialize library, uri, procedure, start_time = nil # :nodoc:
+        def initialize(library, uri, procedure, start_time = nil) # :nodoc:
           @library = library
           @uri = HTTPClients::URIUtil.obfuscated_uri(uri)
           @procedure = procedure
           @host_header = nil
           @app_data = nil
           @http_status_code = nil
+          @record_agent_attributes = false
           super(nil, nil, start_time)
         end
 
@@ -43,6 +44,14 @@ module NewRelic
           @host_header || uri.host
         end
 
+        # By default external request segments only have errors and the http
+        # url recorded as agent attributes. To have all the agent attributes
+        # recorded, use the attr_writer like so `segment.record_agent_attributes = true`
+        # See: SpanEventPrimitive#for_external_request_segment
+        def record_agent_attributes?
+          @record_agent_attributes
+        end
+
         # This method adds New Relic request headers to a given request made to an
         # external API and checks to see if a host header is used for the request.
         # If a host header is used, it updates the segment name to match the host
@@ -52,16 +61,16 @@ module NewRelic
         # object (must belong to a subclass of NewRelic::Agent::HTTPClients::AbstractRequest)
         #
         # @api public
-        def add_request_headers request
-          process_host_header request
+        def add_request_headers(request)
+          process_host_header(request)
           synthetics_header = transaction && transaction.raw_synthetics_header
-          insert_synthetics_header request, synthetics_header if synthetics_header
+          insert_synthetics_header(request, synthetics_header) if synthetics_header
 
           return unless record_metrics?
 
-          transaction.distributed_tracer.insert_headers request
+          transaction.distributed_tracer.insert_headers(request)
         rescue => e
-          NewRelic::Agent.logger.error "Error in add_request_headers", e
+          NewRelic::Agent.logger.error("Error in add_request_headers", e)
         end
 
         # This method extracts app data from an external response if present. If
@@ -71,11 +80,11 @@ module NewRelic
         # @param [Hash] response a hash of response headers
         #
         # @api public
-        def read_response_headers response
+        def read_response_headers(response)
           return unless record_metrics? && CrossAppTracing.cross_app_enabled?
           return unless CrossAppTracing.response_has_crossapp_header?(response)
           unless data = CrossAppTracing.extract_appdata(response)
-            NewRelic::Agent.logger.debug "Couldn't extract_appdata from external segment response"
+            NewRelic::Agent.logger.debug("Couldn't extract_appdata from external segment response")
             return
           end
 
@@ -83,10 +92,10 @@ module NewRelic
             @app_data = data
             update_segment_name
           else
-            NewRelic::Agent.logger.debug "External segment response has invalid cross_app_id"
+            NewRelic::Agent.logger.debug("External segment response has invalid cross_app_id")
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error in read_response_headers", e
+          NewRelic::Agent.logger.error("Error in read_response_headers", e)
         end
 
         def cross_app_request? # :nodoc:
@@ -141,11 +150,11 @@ module NewRelic
 
             # obfuscate the generated request metadata JSON
             #
-            obfuscator.obfuscate ::JSON.dump(rmd)
+            obfuscator.obfuscate(::JSON.dump(rmd))
 
           end
         rescue => e
-          NewRelic::Agent.logger.error "error during get_request_metadata", e
+          NewRelic::Agent.logger.error("error during get_request_metadata", e)
         end
 
         # Process obfuscated +String+ sent from a called application that is also running a New Relic agent and
@@ -156,24 +165,24 @@ module NewRelic
         #
         # @api public
         #
-        def process_response_metadata response_metadata
+        def process_response_metadata(response_metadata)
           NewRelic::Agent.record_api_supportability_metric(:process_response_metadata)
           if transaction
             app_data = ::JSON.parse(obfuscator.deobfuscate(response_metadata))[APP_DATA_KEY]
 
             # validate cross app id
             #
-            if Array === app_data and CrossAppTracing.trusted_valid_cross_app_id? app_data[0]
+            if Array === app_data and CrossAppTracing.trusted_valid_cross_app_id?(app_data[0])
               @app_data = app_data
               update_segment_name
             else
-              NewRelic::Agent.logger.error "error processing response metadata: invalid/non-trusted ID"
+              NewRelic::Agent.logger.error("error processing response metadata: invalid/non-trusted ID")
             end
           end
 
           nil
         rescue => e
-          NewRelic::Agent.logger.error "error during process_response_metadata", e
+          NewRelic::Agent.logger.error("error during process_response_metadata", e)
         end
 
         def record_metrics
@@ -181,24 +190,24 @@ module NewRelic
           super
         end
 
-        def process_response_headers response # :nodoc:
-          set_http_status_code response
-          read_response_headers response
+        def process_response_headers(response) # :nodoc:
+          set_http_status_code(response)
+          read_response_headers(response)
         end
 
         private
 
         # Only sets the http_status_code if response.status_code is non-empty value
-        def set_http_status_code response
-          if response.respond_to? :status_code
+        def set_http_status_code(response)
+          if response.respond_to?(:status_code)
             @http_status_code = response.status_code if response.has_status_code?
           else
-            NewRelic::Agent.logger.warn "Cannot extract HTTP Status Code from response #{response.class.to_s}"
-            NewRelic::Agent.record_metric "#{name}/#{MISSING_STATUS_CODE}", 1
+            NewRelic::Agent.logger.warn("Cannot extract HTTP Status Code from response #{response.class.to_s}")
+            NewRelic::Agent.record_metric("#{name}/#{MISSING_STATUS_CODE}", 1)
           end
         end
 
-        def insert_synthetics_header request, header
+        def insert_synthetics_header(request, header)
           request[NR_SYNTHETICS_HEADER] = header
         end
 
@@ -211,7 +220,7 @@ module NewRelic
           super
         end
 
-        def process_host_header request
+        def process_host_header(request)
           if @host_header = request.host_from_header
             update_segment_name
           end

data/lib/new_relic/agent/transaction/message_broker_segment.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 # 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 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/distributed_tracing/cross_app_tracing'
@@ -66,7 +67,7 @@ module NewRelic
           @destination_name = destination_name
           @headers = headers
           super(nil, nil, start_time)
-          params.merge! parameters if parameters
+          params.merge!(parameters) if parameters
         end
 
         def name
@@ -85,12 +86,12 @@ module NewRelic
 
         def transaction_assigned
           if headers && transaction && action == :produce && record_metrics?
-            transaction.distributed_tracer.insert_distributed_trace_header headers
-            transaction.distributed_tracer.insert_cat_headers headers
-            transaction.distributed_tracer.log_request_headers headers
+            transaction.distributed_tracer.insert_distributed_trace_header(headers)
+            transaction.distributed_tracer.insert_cat_headers(headers)
+            transaction.distributed_tracer.log_request_headers(headers)
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error during message header processing", e
+          NewRelic::Agent.logger.error("Error during message header processing", e)
         end
       end
     end

data/lib/new_relic/agent/transaction/request_attributes.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 # 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 'new_relic/agent/http_clients/uri_util'
 
@@ -13,56 +14,56 @@ module NewRelic
 
         HTTP_ACCEPT_HEADER_KEY = "HTTP_ACCEPT".freeze
 
-        def initialize request
-          @request_path = path_from_request request
-          @referer = referer_from_request request
-          @accept = attribute_from_env request, HTTP_ACCEPT_HEADER_KEY
-          @content_length = content_length_from_request request
-          @content_type = attribute_from_request request, :content_type
-          @host = attribute_from_request request, :host
-          @port = port_from_request request
-          @user_agent = attribute_from_request request, :user_agent
-          @request_method = attribute_from_request request, :request_method
+        def initialize(request)
+          @request_path = path_from_request(request)
+          @referer = referer_from_request(request)
+          @accept = attribute_from_env(request, HTTP_ACCEPT_HEADER_KEY)
+          @content_length = content_length_from_request(request)
+          @content_type = attribute_from_request(request, :content_type)
+          @host = attribute_from_request(request, :host)
+          @port = port_from_request(request)
+          @user_agent = attribute_from_request(request, :user_agent)
+          @request_method = attribute_from_request(request, :request_method)
         end
 
-        def assign_agent_attributes txn
+        def assign_agent_attributes(txn)
           default_destinations = AttributeFilter::DST_TRANSACTION_TRACER |
             AttributeFilter::DST_TRANSACTION_EVENTS |
             AttributeFilter::DST_ERROR_COLLECTOR
 
           if referer
-            txn.add_agent_attribute :'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR
+            txn.add_agent_attribute(:'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR)
           end
 
           if request_path
-            txn.add_agent_attribute :'request.uri',
+            txn.add_agent_attribute(:'request.uri',
               request_path,
               AttributeFilter::DST_TRANSACTION_TRACER |
-                AttributeFilter::DST_ERROR_COLLECTOR
+                AttributeFilter::DST_ERROR_COLLECTOR)
           end
 
           if accept
-            txn.add_agent_attribute :'request.headers.accept', accept, default_destinations
+            txn.add_agent_attribute(:'request.headers.accept', accept, default_destinations)
           end
 
           if content_length
-            txn.add_agent_attribute :'request.headers.contentLength', content_length, default_destinations
+            txn.add_agent_attribute(:'request.headers.contentLength', content_length, default_destinations)
           end
 
           if content_type
-            txn.add_agent_attribute :'request.headers.contentType', content_type, default_destinations
+            txn.add_agent_attribute(:'request.headers.contentType', content_type, default_destinations)
           end
 
           if host
-            txn.add_agent_attribute :'request.headers.host', host, default_destinations
+            txn.add_agent_attribute(:'request.headers.host', host, default_destinations)
           end
 
           if user_agent
-            txn.add_agent_attribute :'request.headers.userAgent', user_agent, default_destinations
+            txn.add_agent_attribute(:'request.headers.userAgent', user_agent, default_destinations)
           end
 
           if request_method
-            txn.add_agent_attribute :'request.method', request_method, default_destinations
+            txn.add_agent_attribute(:'request.method', request_method, default_destinations)
           end
         end
 
@@ -71,9 +72,9 @@ module NewRelic
         # Make a safe attempt to get the referer from a request object, generally successful when
         # it's a Rack request.
 
-        def referer_from_request request
+        def referer_from_request(request)
           if referer = attribute_from_request(request, :referer)
-            HTTPClients::URIUtil.strip_query_string referer.to_s
+            HTTPClients::URIUtil.strip_query_string(referer.to_s)
           end
         end
 
@@ -87,31 +88,31 @@ module NewRelic
 
         ROOT_PATH = "/".freeze
 
-        def path_from_request request
+        def path_from_request(request)
           path = attribute_from_request(request, :path) || ''
           path = HTTPClients::URIUtil.strip_query_string(path)
           path.empty? ? ROOT_PATH : path
         end
 
-        def content_length_from_request request
+        def content_length_from_request(request)
           if content_length = attribute_from_request(request, :content_length)
             content_length.to_i
           end
         end
 
-        def port_from_request request
+        def port_from_request(request)
           if port = attribute_from_request(request, :port)
             port.to_i
           end
         end
 
-        def attribute_from_request request, attribute_method
-          if request.respond_to? attribute_method
+        def attribute_from_request(request, attribute_method)
+          if request.respond_to?(attribute_method)
             request.send(attribute_method)
           end
         end
 
-        def attribute_from_env request, key
+        def attribute_from_env(request, key)
           if env = attribute_from_request(request, :env)
             env[key]
           end