appsignal 5.0.0.rc.1-java → 5.0.0.rc.2-java

data/lib/appsignal/integrations/railtie.rb

@@ -13,8 +13,10 @@ module Appsignal
       config.appsignal = ActiveSupport::OrderedOptions.new
       config.appsignal.start_at = :on_load
 
-      # Run after the Rails framework is loaded
-      initializer "appsignal.configure_rails_initialization" do |app|
+      # Runs before `load_config_initializers` so that AppSignal has started
+      # when the app's initializers run, and errors they raise are reported.
+      initializer "appsignal.configure_rails_initialization",
+        :before => :load_config_initializers do |app|
         Appsignal::Integrations::Railtie.on_load(app)
       end
 

data/lib/appsignal/integrations/resque.rb

@@ -7,12 +7,14 @@ module Appsignal
       def perform
         # Read trace context off the job so the transaction links back to the
         # enqueuer. No-op outside collector mode.
+        job_data = ResqueHelpers.active_job_data(payload)
         transaction = Appsignal::Transaction.create(
           Appsignal::Transaction::BACKGROUND_JOB,
-          :opentelemetry_context => Appsignal::OpenTelemetry.extract_job_context(payload),
+          :opentelemetry_context => ResqueHelpers.extract_context(payload, job_data),
           :opentelemetry_scope => ["appsignal-ruby/resque", Appsignal::VERSION],
           :opentelemetry_kind => :consumer,
-          :opentelemetry_relationship => :both
+          :opentelemetry_relationship =>
+            Appsignal::OpenTelemetry.active_job_relationship(job_data)
         )
         # Describes this span as a job being performed. The messaging system is
         # what the trace timeline reads to recognize background job work, and
@@ -93,14 +95,35 @@ module Appsignal
 
     # @!visibility private
     class ResqueHelpers
+      # The class the Active Job adapter enqueues, with the serialized job data
+      # as its only argument.
+      ACTIVE_JOB_WRAPPER = "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
+
       def self.arguments(payload)
         case payload["class"]
-        when "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
+        when ACTIVE_JOB_WRAPPER
           nil # Set in the ActiveJob integration
         else
           payload["args"]
         end
       end
+
+      # The serialized Active Job job data inside a Resque job, or nil when this
+      # is not an Active Job job.
+      def self.active_job_data(payload)
+        return unless payload["class"] == ACTIVE_JOB_WRAPPER
+
+        job_data = payload["args"]&.first
+        job_data if job_data.is_a?(Hash)
+      end
+
+      # The trace context to continue: the Active Job layer when this is an
+      # Active Job job, the Resque job itself otherwise. See `Appsignal::OpenTelemetry.extract_active_job_context`
+      # for why that layer wins.
+      def self.extract_context(payload, job_data)
+        Appsignal::OpenTelemetry.extract_active_job_context(job_data) ||
+          Appsignal::OpenTelemetry.extract_job_context(payload)
+      end
     end
   end
 end

data/lib/appsignal/integrations/shoryuken.rb

@@ -77,14 +77,18 @@ module Appsignal
         # links back to the enqueuer. A batch carries messages from multiple
         # traces with no single parent, so only single messages link back.
         # No-op outside collector mode.
-        context = ShoryukenTraceContext.extract(sqs_msg.message_attributes) unless batch
+        context = extract_context(sqs_msg, body) unless batch
 
         transaction = Appsignal::Transaction.create(
           Appsignal::Transaction::BACKGROUND_JOB,
           :opentelemetry_context => context,
           :opentelemetry_scope => ["appsignal-ruby/shoryuken", Appsignal::VERSION],
           :opentelemetry_kind => :consumer,
-          :opentelemetry_relationship => :both
+          # A message batch is a batch on the receiving side, and carries no
+          # context to relate to at all, so the body it reads here is the single
+          # message's job data or nothing.
+          :opentelemetry_relationship =>
+            Appsignal::OpenTelemetry.active_job_relationship(batch ? nil : body)
         )
         # Describes this span as a job being performed. The messaging system is
         # what the trace timeline reads to recognize background job work.
@@ -127,6 +131,21 @@ module Appsignal
 
       private
 
+      # The trace context to continue: the Active Job layer when this is an
+      # Active Job job, the message's own attributes otherwise. See `Appsignal::OpenTelemetry.extract_active_job_context`
+      # for why that layer wins.
+      # SQS allows ten message attributes per message, shared with whatever the
+      # user puts there.
+      #
+      # The Active Job adapter registers a worker that parses the message body as
+      # JSON, so an Active Job job's body arrives here as its serialized job
+      # data. Nothing checks that it is one: a body with no readable trace
+      # context in it reads as "nothing here" on its own.
+      def extract_context(sqs_msg, body)
+        Appsignal::OpenTelemetry.extract_active_job_context(body) ||
+          ShoryukenTraceContext.extract(sqs_msg.message_attributes)
+      end
+
       def fetch_attributes(batch, sqs_msg)
         if batch
           # We can't instrument batched message separately, the `yield` will

data/lib/appsignal/integrations/sidekiq.rb

@@ -176,12 +176,14 @@ module Appsignal
         action_name = formatted_action_name(item)
         # Read trace context off the job so the transaction links back to the
         # enqueuer. No-op outside collector mode.
+        job_data = active_job_data(item)
         transaction = Appsignal::Transaction.create(
           Appsignal::Transaction::BACKGROUND_JOB,
-          :opentelemetry_context => Appsignal::OpenTelemetry.extract_job_context(item),
+          :opentelemetry_context => extract_context(item, job_data),
           :opentelemetry_scope => ["appsignal-ruby/sidekiq", Appsignal::VERSION],
           :opentelemetry_kind => :consumer,
-          :opentelemetry_relationship => :both
+          :opentelemetry_relationship =>
+            Appsignal::OpenTelemetry.active_job_relationship(job_data)
         )
         transaction.add_opentelemetry_attributes(
           Appsignal::OpenTelemetry::Messaging
@@ -246,6 +248,25 @@ module Appsignal
 
       private
 
+      # The trace context to continue: the Active Job layer when this is an
+      # Active Job job, the Sidekiq job itself otherwise. See `Appsignal::OpenTelemetry.extract_active_job_context`
+      # for why that layer wins.
+      def extract_context(item, job_data)
+        Appsignal::OpenTelemetry.extract_active_job_context(job_data) ||
+          Appsignal::OpenTelemetry.extract_job_context(item)
+      end
+
+      # The serialized Active Job job data inside a Sidekiq job, or nil when this
+      # is not an Active Job job. Both Active Job adapters for Sidekiq, the one in
+      # Rails and the one in the Sidekiq gem, enqueue a wrapper class with the
+      # job data as its only argument and name the real job class in `wrapped`.
+      def active_job_data(item)
+        return unless item["wrapped"]
+
+        job_data = item["args"]&.first
+        job_data if job_data.is_a?(Hash)
+      end
+
       def increment_counter(key, value, tags = {})
         Appsignal.increment_counter "sidekiq_#{key}", value, tags
       end

data/lib/appsignal/integrations/webmachine.rb

@@ -30,22 +30,30 @@ module Appsignal
           # Set here, where the transaction is created, so they land on the
           # transaction's own span rather than on the event started below.
           #
-          # Webmachine isn't Rack: the path, scheme and query string come off the
-          # request's `URI` rather than from Rack's readers. The request's own
-          # `query` is the parsed form, so the URI is where the string itself is.
+          # Webmachine isn't Rack: the path, scheme, query string, host and port
+          # come off the request's `URI` rather than from Rack's readers. The
+          # request's own `query` is the parsed form, so the URI is where the
+          # string itself is. Webmachine has no environment to read the protocol
+          # version from, so that one is left undescribed.
           transaction.add_opentelemetry_attributes(
             Appsignal::OpenTelemetry::HttpServerRequest.attributes_for(
               :method => request.method,
               :path => request.uri&.path,
               :scheme => request.uri&.scheme,
-              :query => request.uri&.query
+              :query => request.uri&.query,
+              :host => request.uri&.host,
+              :port => request.uri&.port
             )
           )
         end
 
         begin
           transaction.add_query_parameters_if_nil { request.query }
-          transaction.add_headers_if_nil { request.headers if request.respond_to?(:headers) }
+          # `Webmachine::Headers` names a header the way OpenTelemetry does, in
+          # lowercase and with dashes, so these are headers and nothing else.
+          transaction.add_request_headers_if_nil do
+            request.headers if request.respond_to?(:headers)
+          end
 
           Appsignal.instrument(
             "process_action.webmachine",

data/lib/appsignal/opentelemetry/http_server_request.rb

@@ -21,6 +21,15 @@ module Appsignal
     # collector filters it with the `filter_request_query_parameters` option, and
     # builds the request's query parameters out of it.
     #
+    # The host and the port describe where the client addressed the request. The
+    # conventions ask for the host the client used, so a caller reads it through
+    # the `Forwarded` and `X-Forwarded-Host` headers before falling back to the
+    # `Host` header and then to the server's own name. That is the order
+    # `Rack::Request#hostname` already follows. The port is only reported
+    # alongside a host, which is the condition the conventions put on it.
+    #
+    # The protocol version is the version out of `HTTP/1.1`, without the name.
+    #
     # Every value is optional, because reading any of them from the request can
     # fail. An attribute we have no value for is left out rather than sent
     # empty.
@@ -28,17 +37,42 @@ module Appsignal
       PATH_ATTRIBUTE = "url.path"
       SCHEME_ATTRIBUTE = "url.scheme"
       QUERY_ATTRIBUTE = "url.query"
+      ADDRESS_ATTRIBUTE = "server.address"
+      PORT_ATTRIBUTE = "server.port"
+      PROTOCOL_VERSION_ATTRIBUTE = "network.protocol.version"
 
       class << self
         # The attributes describing the given request, as a Hash to pass to
         # `add_opentelemetry_attributes`.
-        def attributes_for(method:, path: nil, scheme: nil, query: nil)
+        def attributes_for( # rubocop:disable Metrics/ParameterLists
+          method:, path: nil, scheme: nil, query: nil, host: nil, port: nil, protocol: nil
+        )
           attributes = HttpMethod.attributes_for(method)
           attributes[PATH_ATTRIBUTE] = path.to_s unless path.to_s.empty?
           attributes[SCHEME_ATTRIBUTE] = scheme.to_s unless scheme.to_s.empty?
           attributes[QUERY_ATTRIBUTE] = query.to_s unless query.to_s.empty?
+
+          unless host.to_s.empty?
+            attributes[ADDRESS_ATTRIBUTE] = host.to_s
+            port = Integer(port, :exception => false)
+            attributes[PORT_ATTRIBUTE] = port if port
+          end
+
+          version = protocol_version_for(protocol)
+          attributes[PROTOCOL_VERSION_ATTRIBUTE] = version if version
+
           attributes
         end
+
+        private
+
+        # `network.protocol.name` is asked for alongside the version only when
+        # the protocol is not HTTP. A value shaped any other way than `HTTP/x`
+        # is one we cannot name, so it is left out entirely rather than sent as
+        # a version with no name to go with it.
+        def protocol_version_for(protocol)
+          protocol.to_s[%r{\AHTTP/(.+)\z}, 1]
+        end
       end
     end
   end

data/lib/appsignal/opentelemetry/proxied_exporter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Appsignal
+  module OpenTelemetry
+    # @!visibility private
+    #
+    # Routes an OTLP exporter's requests through the proxy in the
+    # `http_proxy` config option.
+    #
+    # The exporters accept no proxy and expose no way to reach the connection
+    # they build. They do build it in one method, `http_connection`, which
+    # this module overrides to configure the connection it returns.
+    #
+    # This module is included into a subclass rather than prepended onto the
+    # exporter itself, so that an application using the OpenTelemetry gems for
+    # its own exporting is unaffected.
+    #
+    # That method is not part of the exporters' public API, so a later version
+    # can rename it, stop calling it, or return something other than a
+    # `Net::HTTP` from it. This module does not try to predict which of those
+    # happened by inspecting the method. It records whether it managed to
+    # configure a connection, and {#initialize} reports it when it did not, so
+    # a version we cannot proxy through is visible in the log rather than
+    # silently sending around the proxy.
+    module ProxiedExporter
+      def initialize(appsignal_http_proxy:, **kwargs)
+        @appsignal_http_proxy = appsignal_http_proxy
+        @appsignal_proxy_applied = false
+
+        # The exporters build their connection while they initialize, so by
+        # the time this returns the override below has either run or never
+        # will.
+        super(**kwargs)
+
+        return if @appsignal_proxy_applied
+
+        Appsignal.internal_logger.error(
+          "Not sending #{self.class.superclass} data through the proxy in " \
+            "the `http_proxy` option: this version of the OpenTelemetry " \
+            "exporters does not build its connection where AppSignal " \
+            "configures the proxy."
+        )
+      end
+
+      # Whether the proxy was applied to the connection this exporter sends
+      # through. False means the exporter sends straight to its endpoint.
+      def appsignal_proxy_applied?
+        @appsignal_proxy_applied
+      end
+
+      private
+
+      # Accepts and forwards whatever the exporter calls this with, because
+      # none of the arguments are read here. A version that adds an argument,
+      # positional or keyword, is passed straight through instead of raising
+      # on the way to `super`.
+      def http_connection(*args, **kwargs)
+        apply_appsignal_proxy(super)
+      end
+
+      # Point a connection at the proxy. Returns the connection either way, so
+      # an exporter whose connection cannot be proxied still sends its data.
+      def apply_appsignal_proxy(http)
+        return http unless http.respond_to?(:proxy_from_env=)
+
+        proxy = URI.parse(@appsignal_http_proxy)
+
+        # `Net::HTTP#proxy?` reads the address only when the connection is not
+        # taking its proxy from the environment, which it does by default.
+        http.proxy_from_env = false
+        http.proxy_address = proxy.host
+        http.proxy_port = proxy.port
+        http.proxy_user = proxy.user
+        http.proxy_pass = proxy.password
+
+        @appsignal_proxy_applied = true
+        http
+      end
+    end
+  end
+end

data/lib/appsignal/opentelemetry.rb

@@ -8,12 +8,18 @@ require "appsignal/opentelemetry/http_method"
 require "appsignal/opentelemetry/http_response"
 require "appsignal/opentelemetry/http_server_request"
 require "appsignal/opentelemetry/messaging"
+require "appsignal/opentelemetry/proxied_exporter"
 require "appsignal/opentelemetry/rendering"
 require "appsignal/opentelemetry/sql_db_system"
 
 module Appsignal
   # @!visibility private
   module OpenTelemetry
+    # The carrier key that marks an Active Job job as one of a batch. Not a W3C
+    # trace context header, and deliberately not named like one, so no
+    # propagator reads it as one.
+    ACTIVE_JOB_BATCH_HEADER = "appsignal-batch"
+
     class << self
       # Configure the global OpenTelemetry SDK to export OTLP/HTTP protobuf to
       # the collector endpoint in `config[:collector_endpoint]`.
@@ -55,14 +61,16 @@ module Appsignal
         # resource for the tracer provider to keep all three in sync.
         resource = ::OpenTelemetry::SDK::Resources::Resource.default.merge(build_resource(config))
 
+        span_exporter = build_exporter(
+          ::OpenTelemetry::Exporter::OTLP::Exporter,
+          config,
+          :endpoint => "#{endpoint}/v1/traces"
+        )
+
         ::OpenTelemetry::SDK.configure do |c|
           c.resource = resource
           c.add_span_processor(
-            ::OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
-              ::OpenTelemetry::Exporter::OTLP::Exporter.new(
-                :endpoint => "#{endpoint}/v1/traces"
-              )
-            )
+            ::OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(span_exporter)
           )
         end
 
@@ -72,22 +80,26 @@ module Appsignal
         # `force_flush` is a no-op.
         ::OpenTelemetry.meter_provider =
           ::OpenTelemetry::SDK::Metrics::MeterProvider.new(:resource => resource)
+        metrics_exporter = build_exporter(
+          ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter,
+          config,
+          :endpoint => "#{endpoint}/v1/metrics"
+        )
         ::OpenTelemetry.meter_provider.add_metric_reader(
           ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
-            :exporter => ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.new(
-              :endpoint => "#{endpoint}/v1/metrics"
-            )
+            :exporter => metrics_exporter
           )
         )
 
+        logs_exporter = build_exporter(
+          ::OpenTelemetry::Exporter::OTLP::Logs::LogsExporter,
+          config,
+          :endpoint => "#{endpoint}/v1/logs"
+        )
         ::OpenTelemetry.logger_provider =
           ::OpenTelemetry::SDK::Logs::LoggerProvider.new(:resource => resource)
         ::OpenTelemetry.logger_provider.add_log_record_processor(
-          ::OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(
-            ::OpenTelemetry::Exporter::OTLP::Logs::LogsExporter.new(
-              :endpoint => "#{endpoint}/v1/logs"
-            )
-          )
+          ::OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(logs_exporter)
         )
 
         @started = true
@@ -159,9 +171,8 @@ module Appsignal
       def extract_job_context(item)
         if_started do
           carrier = item
-          nested = item["__otel_headers"]
-          nested = nested.to_h if otel_header_pairs?(nested)
-          carrier = item.merge(nested) if nested.is_a?(Hash)
+          nested = otel_headers_hash(item["__otel_headers"])
+          carrier = item.merge(nested) if nested
           # Extract onto an empty context rather than the default
           # `Context.current`, for the same reason as `extract_rack_context`:
           # a job with no injected trace context must not inherit an ambient
@@ -174,6 +185,107 @@ module Appsignal
         end
       end
 
+      # Read the trace context off the serialized Active Job job data that a
+      # queue adapter's job wraps, so the transaction the adapter creates links
+      # back to the enqueuer.
+      #
+      # Every adapter wraps the job data as the single argument of its own job
+      # wrapper, but each keeps it somewhere different, so finding the job data
+      # is the adapter integration's business and reading a context out of it is
+      # this method's.
+      #
+      # This is the layer every integration prefers. Active Job owns the job
+      # whichever adapter carries it, its carrier survives an adapter that has
+      # nowhere of its own to put a header, and it does not compete with the
+      # user's own data for a carrier with a hard limit on what fits.
+      #
+      # Returns `nil` when the SDK has not booted, when this is not Active Job
+      # job data, and when the job data carries no usable context. A caller reads
+      # that `nil` as "nothing here" and falls back to its own native carrier.
+      # That fallback matters twice over: it is where a job enqueued by a service
+      # that instruments only the adapter carries its context, and it is the only
+      # carrier a job that is not an Active Job job has at all.
+      def extract_active_job_context(job_data)
+        return unless job_data.is_a?(Hash)
+
+        if_started do
+          headers = otel_headers_hash(job_data["__otel_headers"])
+          next unless headers
+
+          # Extract onto an empty context, for the same reason as
+          # `extract_job_context` above.
+          context = ::OpenTelemetry.propagation.extract(
+            headers,
+            :context => ::OpenTelemetry::Context.empty
+          )
+          context if remote_span_context(context)
+        end
+      end
+
+      # Marks an outgoing Active Job carrier as belonging to a batch, so the
+      # integration that later performs the job can tell the two enqueue paths
+      # apart. Every job in a batch shares the one producer span, and a span can
+      # have only one parent, so a batch has to link back rather than parent
+      # under it -- and only the enqueue side knows it was a batch.
+      #
+      # The marker rides in the same carrier as the trace context.
+      # `propagation.extract` ignores a key it does not recognise, so it is
+      # invisible to every other reader of that carrier, including
+      # OpenTelemetry's own Active Job instrumentation.
+      #
+      # Does nothing to a carrier nothing was injected into. Without a context
+      # there is no producer span to link back to, so the marker would have
+      # nothing to say.
+      def mark_active_job_batch(headers)
+        return if headers.empty?
+
+        headers[ACTIVE_JOB_BATCH_HEADER] = "1"
+      end
+
+      # Whether Active Job job data says the job was enqueued as part of a batch.
+      # An integration reads this to choose between linking the performed job
+      # back to the enqueuer and also parenting it under them.
+      def active_job_batch?(job_data)
+        return false unless job_data.is_a?(Hash)
+
+        headers = otel_headers_hash(job_data["__otel_headers"])
+        return false unless headers
+
+        headers[ACTIVE_JOB_BATCH_HEADER] == "1"
+      end
+
+      # How a performed job should relate to the span that enqueued it.
+      #
+      # A job enqueued on its own is the only job its producer span produced, so
+      # it can be a child of that span as well as link to it. Every job in a
+      # batch shares one producer span, and a span can have only one parent, so
+      # parenting a batch would hang the whole batch off that single span. Only
+      # link those, which is what the OpenTelemetry messaging conventions ask
+      # for: they use links as the default, and allow the producer to be the
+      # parent only when it produced a single message.
+      def active_job_relationship(job_data)
+        active_job_batch?(job_data) ? :link : :both
+      end
+
+      # The remote parent's SpanContext from an incoming OTel context, or `nil`
+      # when there is no context or the span in it is invalid.
+      #
+      # `propagation.extract` returns a context whether or not the carrier held
+      # anything, so this is what tells "read a context" apart from "read
+      # nothing". A caller that can fall back to another carrier uses it to
+      # decide whether to, and a caller that parents or links a span uses it to
+      # decide between doing that and starting a plain root span.
+      #
+      # Only ever called with a context that came from the OpenTelemetry SDK, so
+      # it does not gate on the SDK having booted the way the extract methods do.
+      def remote_span_context(opentelemetry_context)
+        return unless opentelemetry_context
+
+        span_context =
+          ::OpenTelemetry::Trace.current_span(opentelemetry_context).context
+        span_context if span_context.valid?
+      end
+
       # Run `block` only when the OpenTelemetry SDK has booted (collector mode),
       # returning its result; a no-op returning `nil` otherwise. The block can
       # touch the OTel SDK freely -- it only runs when the SDK is loaded.
@@ -212,10 +324,12 @@ module Appsignal
 
       # Build the OpenTelemetry Resource that carries AppSignal config to the
       # collector. Attributes whose underlying option is nil or an empty array
-      # are omitted so the collector applies its own defaults.
+      # are omitted so the collector applies its own defaults. The revision,
+      # service name and host name are the exception: they fall back to a
+      # value here, so they are always sent.
       def build_resource(config)
         revision = config[:revision].to_s.empty? ? "unknown" : config[:revision]
-        service_name = config[:service_name].to_s.empty? ? "unknown" : config[:service_name]
+        service_name = config[:service_name].to_s.empty? ? "app" : config[:service_name]
         host_name = config[:hostname].to_s.empty? ? "unknown" : config[:hostname]
 
         attrs = {
@@ -223,6 +337,8 @@ module Appsignal
           "appsignal.config.environment" => config.env,
           "appsignal.config.push_api_key" => config[:push_api_key],
           "appsignal.config.revision" => revision,
+          "appsignal.config.app_path" => config.root_path&.to_s,
+          "appsignal.config.platform" => config[:platform],
           "appsignal.config.language_integration" => "ruby",
           "service.name" => service_name,
           "host.name" => host_name,
@@ -234,25 +350,67 @@ module Appsignal
           "appsignal.config.filter_request_session_data" => config[:filter_session_data],
           "appsignal.config.ignore_actions" => config[:ignore_actions],
           "appsignal.config.ignore_errors" => config[:ignore_errors],
+          "appsignal.config.ignore_logs" => config[:ignore_logs],
           "appsignal.config.ignore_namespaces" => config[:ignore_namespaces],
-          "appsignal.config.response_headers" => config[:response_headers],
-          "appsignal.config.request_headers" => config[:request_headers],
+          "appsignal.config.response_headers" =>
+            normalized_header_names(config[:response_headers]),
+          # The collector filters `http.request.header.*` attributes by their
+          # OpenTelemetry names, which is what `keep_request_headers` holds.
+          "appsignal.config.request_headers" =>
+            normalized_header_names(config[:keep_request_headers]),
           "appsignal.config.send_function_parameters" => config[:send_function_parameters],
           "appsignal.config.send_request_query_parameters" =>
             config[:send_request_query_parameters],
           "appsignal.config.send_request_payload" => config[:send_request_payload],
           "appsignal.config.send_request_session_data" => config[:send_session_data]
         }
-        attrs.reject! { |_, v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+        # An absent attribute leaves the collector its own default, which an empty
+        # allowlist cannot say, so an empty list is sent and an unset option is not.
+        attrs.reject! { |_, value| value.nil? || value == "" }
         ::OpenTelemetry::SDK::Resources::Resource.create(attrs)
       end
 
       private
 
+      def normalized_header_names(names)
+        names.map { |name| Appsignal::Utils::RequestHeaders.normalize(name) }
+      end
+
+      # Build one OTLP exporter, applying the `ca_file_path` and `http_proxy`
+      # options to the requests it sends. The certificate file is a keyword
+      # argument the exporters accept; the proxy is not, so an exporter that
+      # needs one is a subclass that applies it to its own connection.
+      def build_exporter(base, config, **kwargs)
+        certificate_file = config[:ca_file_path].to_s
+        kwargs[:certificate_file] = certificate_file unless certificate_file.empty?
+
+        http_proxy = config[:http_proxy].to_s
+        return base.new(**kwargs) if http_proxy.empty?
+
+        proxied_exporter_class(base).new(:appsignal_http_proxy => http_proxy, **kwargs)
+      end
+
+      # A subclass of an OTLP exporter that routes its requests through a
+      # proxy. Built here rather than declared, because the exporter gems are
+      # only loaded once collector mode is configured.
+      def proxied_exporter_class(base)
+        Class.new(base) { include ProxiedExporter }
+      end
+
+      # A `__otel_headers` value as a hash carrier, or `nil` when there is no
+      # usable one. Active Job puts the headers through its argument serializer,
+      # which turns the hash into an array of `[key, value]` pairs, so both
+      # shapes arrive. Anything else, including a malformed array, gives `nil`
+      # rather than raising on `to_h` inside a job perform.
+      def otel_headers_hash(value)
+        return value if value.is_a?(Hash)
+        return value.to_h if otel_header_pairs?(value)
+
+        nil
+      end
+
       # Whether a `__otel_headers` value is the array-of-`[key, value]`-pairs
-      # shape produced by ActiveJob's argument serializer, so it can be turned
-      # into a hash carrier. Anything else (including a malformed array) is left
-      # alone rather than raising on `to_h` inside a job perform.
+      # shape produced by ActiveJob's argument serializer.
       def otel_header_pairs?(value)
         value.is_a?(Array) && value.all? { |pair| pair.is_a?(Array) && pair.size == 2 }
       end

data/lib/appsignal/rack/abstract_middleware.rb

@@ -98,7 +98,10 @@ module Appsignal
             :method => Appsignal::Rack::Utils.request_method_from(request),
             :path => Appsignal::Rack::Utils.request_value_from(request, :path),
             :scheme => Appsignal::Rack::Utils.request_value_from(request, :scheme),
-            :query => Appsignal::Rack::Utils.request_value_from(request, :query_string)
+            :query => Appsignal::Rack::Utils.request_value_from(request, :query_string),
+            :host => Appsignal::Rack::Utils.request_value_from(request, :hostname),
+            :port => Appsignal::Rack::Utils.request_value_from(request, :port),
+            :protocol => Appsignal::Rack::Utils.request_env_value_from(request, "SERVER_PROTOCOL")
           )
         )
       end

data/lib/appsignal/rack/event_handler.rb

@@ -81,7 +81,11 @@ module Appsignal
               :method => Appsignal::Rack::Utils.request_method_from(request),
               :path => Appsignal::Rack::Utils.request_value_from(request, :path),
               :scheme => Appsignal::Rack::Utils.request_value_from(request, :scheme),
-              :query => Appsignal::Rack::Utils.request_value_from(request, :query_string)
+              :query => Appsignal::Rack::Utils.request_value_from(request, :query_string),
+              :host => Appsignal::Rack::Utils.request_value_from(request, :hostname),
+              :port => Appsignal::Rack::Utils.request_value_from(request, :port),
+              :protocol =>
+                Appsignal::Rack::Utils.request_env_value_from(request, "SERVER_PROTOCOL")
             )
           )
           transaction.start_event(
@@ -141,7 +145,10 @@ module Appsignal
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
           transaction.finish_event("process_request.rack", "callback: on_finish", "")
           transaction.add_request_payload_if_nil { request.params }
-          transaction.add_headers_if_nil { request.env }
+          headers, environment =
+            Appsignal::Utils::RequestHeaders.split_lazily { request.env }
+          transaction.add_request_headers_if_nil(&headers)
+          transaction.add_request_environment_if_nil(&environment)
           transaction.add_session_data_if_nil do
             request.session if request.respond_to?(:session)
           end