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

data/lib/appsignal/rack/grape_middleware.rb

@@ -16,26 +16,56 @@ module Appsignal
 
       def add_transaction_metadata_after(transaction, request)
         endpoint = request.env["api.endpoint"]
-        unless endpoint&.options
+        request_method, klass, path = endpoint && endpoint_action(endpoint)
+        unless path
           super
           return
         end
 
+        transaction.set_action_if_nil("#{request_method}::#{klass}##{path}")
+
+        super
+
+        transaction.set_metadata("path", path)
+      end
+
+      # Returns the HTTP method, API class and path that make up the action
+      # name, or nil when the endpoint does not describe a route.
+      def endpoint_action(endpoint)
         options = endpoint.options
-        request_method = options[:method].first.to_s.upcase
-        klass = options[:for]
+        return unless options
+
+        if options.key?(:path)
+          # Only Grape 3 and older populate `options[:path]`. Their route is
+          # readable too, but its path is the full route template, so reading
+          # it would rename the actions these applications already report.
+          endpoint_action_from_options(endpoint, options)
+        else
+          # Grape 4 keeps these three in a value object behind a protected
+          # reader, leaving the route as the only public source.
+          endpoint_action_from_route(endpoint)
+        end
+      end
+
+      def endpoint_action_from_options(endpoint, options)
         namespace = endpoint.namespace
         namespace = "" if namespace == "/"
 
         path = options[:path].first.to_s
         path = "/#{path}" if path[0] != "/"
-        path = "#{namespace}#{path}"
 
-        transaction.set_action_if_nil("#{request_method}::#{klass}##{path}")
+        [
+          options[:method].first.to_s.upcase,
+          options[:for],
+          "#{namespace}#{path}"
+        ]
+      end
 
-        super
+      def endpoint_action_from_route(endpoint)
+        route = endpoint.routes.first
+        return unless route
 
-        transaction.set_metadata("path", path)
+        [route.request_method.to_s.upcase, endpoint.api, route.origin]
       end
     end
   end

data/lib/appsignal/rack.rb

@@ -47,6 +47,32 @@ module Appsignal
         nil
       end
 
+      # Fetch a value from the request environment, for the values that are only
+      # available there.
+      #
+      # The request class is configurable, so it may have no environment at all,
+      # which is not worth logging about. Reading from one can still raise, and
+      # that is logged. Either way the caller gets nil and skips whatever it
+      # needed the value for.
+      #
+      # @param request [Rack::Request] Request object.
+      # @param key [String] Name of the environment key to read.
+      # @return [Object, NilClass]
+      def self.request_env_value_from(request, key)
+        return unless request.respond_to?(:env)
+
+        env = request.env
+        return unless env
+
+        env[key]
+      rescue => error
+        Appsignal.internal_logger.error(
+          "Exception while fetching the HTTP request environment #{key}: " \
+            "#{error.class}: #{error}"
+        )
+        nil
+      end
+
       # Fetch the queue start time from the request environment.
       #
       # @since 3.11.0
@@ -99,9 +125,11 @@ module Appsignal
 
         transaction.add_request_payload { params_for(request) }
         transaction.add_session_data { session_data_for(request) }
-        transaction.add_headers do
+        headers, environment = Appsignal::Utils::RequestHeaders.split_lazily do
           request.env if request.respond_to?(:env)
         end
+        transaction.add_request_headers(&headers)
+        transaction.add_request_environment(&environment)
 
         queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
         transaction.set_queue_start(queue_start) if queue_start

data/lib/appsignal/transaction/base_backend.rb

@@ -59,6 +59,27 @@ module Appsignal
         raise NotImplementedError
       end
 
+      # Maps each params bucket to the configuration options that decide what
+      # it reports: `:filter`, naming the keys to filter out of it, and
+      # `:send`, deciding whether to report it at all.
+      def params_options
+        raise NotImplementedError
+      end
+
+      # Maps each logical header channel (`:request_headers`,
+      # `:request_environment`) to the storage bucket it lands in and the
+      # transform to apply to each key and value added on it, as
+      # `[bucket, transform]`. A `nil` transform leaves the value alone.
+      def headers_mapping
+        raise NotImplementedError
+      end
+
+      # Maps each header bucket to the configuration option that lists the
+      # keys to keep in it. An option holding `nil` keeps every key.
+      def headers_allowlist
+        raise NotImplementedError
+      end
+
       # Sample data (params, session, tags, ...), breadcrumbs and errors.
       def set_sample_data(_key, _data)
         raise NotImplementedError

data/lib/appsignal/transaction/extension_backend.rb

@@ -96,6 +96,32 @@ module Appsignal
         PARAMS_MAPPING
       end
 
+      PARAMS_OPTIONS = {
+        :params => { :filter => :filter_parameters, :send => :send_params }
+      }.freeze
+
+      def params_options
+        PARAMS_OPTIONS
+      end
+
+      HEADERS_MAPPING = {
+        :request_headers => [
+          :environment,
+          lambda { |name, value| [Appsignal::Utils::RequestHeaders.rack_name(name), value] }
+        ],
+        :request_environment => [:environment, nil]
+      }.freeze
+
+      def headers_mapping
+        HEADERS_MAPPING
+      end
+
+      HEADERS_ALLOWLIST = { :environment => [:request_headers, false] }.freeze
+
+      def headers_allowlist
+        HEADERS_ALLOWLIST
+      end
+
       # `data` is a raw Ruby Hash/Array; the C extension wants a `Data` object,
       # so serialize it here (mirrors how `set_error` serializes its backtrace).
       def set_sample_data(key, data)

data/lib/appsignal/transaction/opentelemetry_backend.rb

@@ -14,6 +14,12 @@ module Appsignal
     class OpenTelemetryBackend < BaseBackend
       TRACER_NAME = "appsignal-ruby"
 
+      # The action name given to a transaction that recorded an error without
+      # ever setting one. Bracketed so it reads as a marker rather than as a
+      # class the application defines, and so it sorts apart from real action
+      # names.
+      UNNAMED_ACTION = "[unnamed action]"
+
       # Guards the process-wide warn-once state, which transactions touch
       # concurrently on threaded servers. A constant so it is created once at
       # load time rather than lazily (which would race).
@@ -125,6 +131,7 @@ module Appsignal
         @start_time = Time.now
         @action_set = false
         @action = nil
+        @error_set = false
         @allocation_start = current_allocation_count
         @root_child_allocation_count = 0
 
@@ -277,6 +284,43 @@ module Appsignal
         PARAMS_MAPPING
       end
 
+      PARAMS_OPTIONS = {
+        :request_payload => {
+          :filter => :filter_request_payload,
+          :send => :send_request_payload
+        },
+        :function_parameters => {
+          :filter => :filter_function_parameters,
+          :send => :send_function_parameters
+        },
+        :query_parameters => {
+          :filter => :filter_request_query_parameters,
+          :send => :send_request_query_parameters
+        }
+      }.freeze
+
+      def params_options
+        PARAMS_OPTIONS
+      end
+
+      HEADERS_MAPPING = {
+        :request_headers => [:request_headers, nil],
+        :request_environment => [:environment, nil]
+      }.freeze
+
+      def headers_mapping
+        HEADERS_MAPPING
+      end
+
+      HEADERS_ALLOWLIST = {
+        :request_headers => [:keep_request_headers, true],
+        :environment => [:keep_request_environment, false]
+      }.freeze
+
+      def headers_allowlist
+        HEADERS_ALLOWLIST
+      end
+
       # Routes each sample-data category to the attribute the collector reads.
       # The params arrive on one of three channels: `request_payload` (web),
       # `function_parameters` (jobs) and `query_parameters` (a request's query
@@ -298,8 +342,10 @@ module Appsignal
           @span.set_attribute("appsignal.request.session_data", JSON.generate(data))
         when "custom_data"
           @span.set_attribute("appsignal.custom_data", JSON.generate(data))
-        when "environment"
+        when "request_headers"
           write_request_headers(data)
+        when "environment"
+          write_request_environment(data)
         when "tags"
           write_tags(data)
         else
@@ -317,6 +363,7 @@ module Appsignal
       # become their own incident. Each cause carries only the part of its
       # backtrace that is not shared (see `trim_shared_tail`).
       def set_error(class_name, message, backtrace, causes, _root_cause_missing)
+        @error_set = true
         span = current_span
         error_lines = Array(backtrace)
 
@@ -392,12 +439,12 @@ module Appsignal
         # `teardown` sets `@completed`, so this guard also makes the body
         # idempotent across a double `complete`, and skips it on `discard`.
         unless @completed
-          # Aggregate metrics are only emitted for a transaction that set an
-          # action to group by. An actionless transaction is never reported in
-          # agent mode, so it must contribute to no aggregate here either.
-          emit_queue_duration_metric if @action_set
+          # Settle the action first, because the allocation count metric below
+          # tags by `@action`, and this is what fills it in for a transaction
+          # the application never named.
+          resolve_missing_action
+          emit_queue_duration_metric if should_report?
           report_allocation_count
-          ignore_subtrace_without_action
         end
         teardown
       end
@@ -450,15 +497,38 @@ module Appsignal
         @span&.finish
       end
 
-      # A transaction that never set an action has nothing to group by, and agent
-      # mode does not report one at all. Collector mode cannot represent "no
-      # action", so the subtrace is flagged for the collector to drop instead,
-      # the same way `discard` does. The flag has to be set before `teardown`
-      # finishes the span, because attributes set on an ended span are dropped.
-      def ignore_subtrace_without_action
+      # Whether this transaction is reported at all. One that set an action is
+      # reported so it can be grouped under it. One that recorded an error is
+      # reported even without an action, because the failure is worth reporting
+      # even when we cannot say what failed. The agent draws the line in the
+      # same place: it drops a transaction only when it has neither.
+      def should_report?
+        @action_set || @error_set
+      end
+
+      # Decides what to do about a transaction that never set an action, which
+      # has nothing to group by. Collector mode cannot represent "no action", so
+      # it needs a name for the ones it reports and a way to drop the rest.
+      #
+      # A reported one is named after the marker. Leaving the action unset would
+      # not report nothing: the collector fills an empty action in from the span
+      # name, which here is the placeholder this backend opened the span with,
+      # and that reads as though it were the application's own action.
+      #
+      # The rest are noise, such as serving assets in development, so their
+      # subtrace is flagged for the collector to drop, the same way `discard`
+      # does.
+      #
+      # Both branches have to run before `teardown` finishes the span, because
+      # attributes set on an ended span are dropped.
+      def resolve_missing_action
         return if @action_set
 
-        @span&.set_attribute("appsignal.ignore_subtrace", true)
+        if should_report?
+          set_action(UNNAMED_ACTION)
+        else
+          @span&.set_attribute("appsignal.ignore_subtrace", true)
+        end
       end
 
       # Emits the queue duration as a distribution metric in both the
@@ -505,7 +575,7 @@ module Appsignal
           count - @root_child_allocation_count
         )
 
-        return unless @action_set && count.positive?
+        return unless should_report? && count.positive?
 
         namespace = display_namespace(@namespace)
         Appsignal::Metrics::OpenTelemetryBackend.increment_counter(
@@ -633,7 +703,7 @@ module Appsignal
       # to a plain root span, since there is nothing to parent or link to.
       def start_transaction_span(namespace, kind, relationship, opentelemetry_context)
         name = placeholder_span_name(namespace)
-        remote = remote_span_context(opentelemetry_context)
+        remote = Appsignal::OpenTelemetry.remote_span_context(opentelemetry_context)
         tracer = tracer_for(@scope)
 
         # With no incoming context (or an invalid remote span) there is nothing
@@ -682,38 +752,19 @@ module Appsignal
         frames.find { |frame| !frame.include?("/lib/appsignal/") } || frames.first
       end
 
-      # The remote parent's SpanContext from an incoming OTel context, or nil
-      # when there is no context or the remote span is invalid -- in which case
-      # callers fall back to a plain root span.
-      def remote_span_context(opentelemetry_context)
-        return unless opentelemetry_context
-
-        context = ::OpenTelemetry::Trace.current_span(opentelemetry_context).context
-        context if context.valid?
-      end
-
       def display_namespace(namespace)
         DISPLAY_NAMESPACE.fetch(namespace, namespace)
       end
 
-      # The transaction's "environment" sample data is a Rack/CGI env allowlist
-      # mixing true HTTP headers (HTTP_*, plus CONTENT_LENGTH/CONTENT_TYPE) with
-      # non-header CGI vars (REQUEST_METHOD, REQUEST_PATH, PATH_INFO, SERVER_*).
-      # Only the true headers map to the OTel `http.request.header.*` convention
-      # the collector and trace UI read, so emit those (normalized to lowercase,
-      # dashed header names) and drop everything else.
       def write_request_headers(headers)
-        headers.each do |key, value|
-          name = otel_header_name(key)
-          @span.set_attribute("http.request.header.#{name}", value.to_s) if name
+        headers.each do |name, value|
+          @span.set_attribute("http.request.header.#{name}", value.to_s)
         end
       end
 
-      def otel_header_name(env_key)
-        if env_key.start_with?("HTTP_")
-          env_key.delete_prefix("HTTP_").downcase.tr("_", "-")
-        elsif env_key.start_with?("CONTENT_")
-          env_key.downcase.tr("_", "-")
+      def write_request_environment(environment)
+        environment.each do |key, value|
+          @span.set_attribute("appsignal.environment.#{key}", value.to_s)
         end
       end