appsignal 4.10.4-java → 5.0.0-java

data/lib/appsignal/rack/abstract_middleware.rb

@@ -20,6 +20,10 @@ module Appsignal
         @options = options
         @request_class = options.fetch(:request_class, ::Rack::Request)
         @instrument_event_name = options.fetch(:instrument_event_name, nil)
+        # The OpenTelemetry instrumentation scope for the request's spans in
+        # collector mode. Each framework middleware sets its own; nil falls back
+        # to the default scope in the backend.
+        @opentelemetry_scope = options.fetch(:opentelemetry_scope, nil)
         @report_errors = options.fetch(:report_errors, DEFAULT_ERROR_REPORTING)
       end
 
@@ -33,7 +37,11 @@ module Appsignal
             if wrapped_instrumentation
               env[Appsignal::Rack::APPSIGNAL_TRANSACTION]
             else
-              Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
+              Appsignal::Transaction.create(
+                Appsignal::Transaction::HTTP_REQUEST,
+                :opentelemetry_context => Appsignal::OpenTelemetry.extract_rack_context(env),
+                :opentelemetry_scope => @opentelemetry_scope
+              )
             end
 
           unless wrapped_instrumentation
@@ -41,6 +49,7 @@ module Appsignal
             # middleware can detect if there is parent instrumentation
             # middleware active.
             env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
+            add_opentelemetry_request_attributes(transaction, request)
           end
 
           begin
@@ -59,8 +68,13 @@ module Appsignal
           ensure
             add_transaction_metadata_after(transaction, request)
 
-            # Complete transaction because this is the top instrumentation middleware.
-            Appsignal::Transaction.complete_current! unless wrapped_instrumentation
+            unless wrapped_instrumentation
+              add_opentelemetry_response_attributes(transaction, request)
+
+              # Complete transaction because this is the top instrumentation
+              # middleware.
+              Appsignal::Transaction.complete_current!
+            end
           end
         else
           @app.call(env)
@@ -69,6 +83,48 @@ module Appsignal
 
       private
 
+      # Describes the transaction's span as an incoming HTTP request. Together
+      # with the SERVER span kind the transaction already carries, this is what
+      # the trace timeline reads to recognize a web request.
+      #
+      # Set where the transaction is created, rather than with the rest of the
+      # request metadata in {ApplyRackRequest}, which runs after the app has been
+      # called: by then an event span may be open, and the attributes would land
+      # on that instead. Only the middleware that created the transaction sets
+      # them, so nested middleware does not write them again.
+      def add_opentelemetry_request_attributes(transaction, request)
+        transaction.add_opentelemetry_attributes(
+          Appsignal::OpenTelemetry::HttpServerRequest.attributes_for(
+            :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),
+            :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
+
+      # Describes the response the app produced on the transaction's span, which
+      # the semantic conventions ask for whenever a response was sent.
+      #
+      # Set from the `ensure` in {#call} rather than from {#call_app}, where the
+      # status is first known. That runs inside the instrumented event, so the
+      # attribute would land on the event span instead of on the transaction's
+      # own span. The status travels between the two in the request environment
+      # for that reason.
+      #
+      # A request whose app raised never produced a status, and is described
+      # without one.
+      def add_opentelemetry_response_attributes(transaction, request)
+        transaction.add_opentelemetry_attributes(
+          Appsignal::OpenTelemetry::HttpResponse.attributes_for(
+            request.env[Appsignal::Rack::APPSIGNAL_RESPONSE_STATUS]
+          )
+        )
+      end
+
       # Another instrumentation middleware is active earlier in the stack, so
       # don't report any exceptions here, the top instrumentation middleware
       # will be the one reporting the exception.
@@ -79,7 +135,10 @@ module Appsignal
       # @see #instrument_app_call_with_exception_handling
       def instrument_app_call(env, transaction)
         if @instrument_event_name
-          Appsignal.instrument(@instrument_event_name) do
+          Appsignal.instrument(
+            @instrument_event_name,
+            :opentelemetry_scope => @opentelemetry_scope
+          ) do
             call_app(env, transaction)
           end
         else
@@ -89,6 +148,9 @@ module Appsignal
 
       def call_app(env, transaction)
         status, headers, obody = @app.call(env)
+        # Remember the status for {#add_opentelemetry_response_attributes}, which
+        # runs once this event has closed.
+        env[Appsignal::Rack::APPSIGNAL_RESPONSE_STATUS] = status
         body =
           if env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED]
             obody

data/lib/appsignal/rack/body_wrapper.rb

@@ -48,7 +48,10 @@ module Appsignal
         # of the body has already closed itself (as prescribed) we do not
         # attempt to close it twice
         if !@body_already_closed && @body.respond_to?(:close)
-          Appsignal.instrument("close_response_body.rack") { @body.close }
+          Appsignal.instrument(
+            "close_response_body.rack",
+            :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+          ) { @body.close }
         end
         @body_already_closed = true
       rescue *IGNORED_ERRORS # Do not report
@@ -104,7 +107,11 @@ module Appsignal
         # in a blockless way it is still a good idea to have it in place.
         return enum_for(:each) unless block_given?
 
-        Appsignal.instrument("process_response_body.rack", "Process Rack response body (#each)") do
+        Appsignal.instrument(
+          "process_response_body.rack",
+          "Process Rack response body (#each)",
+          :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+        ) do
           @body.each(&blk)
         end
       rescue *IGNORED_ERRORS # Do not report
@@ -125,7 +132,11 @@ module Appsignal
       def call(stream)
         # `stream` will be closed by the app we are calling, no need for us
         # to close it ourselves
-        Appsignal.instrument("process_response_body.rack", "Process Rack response body (#call)") do
+        Appsignal.instrument(
+          "process_response_body.rack",
+          "Process Rack response body (#call)",
+          :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+        ) do
           @body.call(stream)
         end
       rescue *IGNORED_ERRORS # Do not report
@@ -150,7 +161,8 @@ module Appsignal
         @body_already_closed = true
         Appsignal.instrument(
           "process_response_body.rack",
-          "Process Rack response body (#to_ary)"
+          "Process Rack response body (#to_ary)",
+          :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
         ) do
           @body.to_ary
         end
@@ -168,7 +180,8 @@ module Appsignal
       def to_path
         Appsignal.instrument(
           "process_response_body.rack",
-          "Process Rack response body (#to_path)"
+          "Process Rack response body (#to_path)",
+          :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
         ) do
           @body.to_path
         end

data/lib/appsignal/rack/event_handler.rb

@@ -63,8 +63,34 @@ module Appsignal
           request.env[APPSIGNAL_EVENT_HANDLER_ID] ||= id
           return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
-          transaction = Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
-          transaction.start_event
+          transaction = Appsignal::Transaction.create(
+            Appsignal::Transaction::HTTP_REQUEST,
+            :opentelemetry_context => Appsignal::OpenTelemetry.extract_rack_context(request.env),
+            :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+          )
+          # Describes the transaction's span as an incoming HTTP request.
+          # Together with the SERVER span kind the transaction already carries,
+          # this is what the trace timeline reads to recognize a web request.
+          #
+          # Set before the event below starts, because attributes go on
+          # whichever span is open and these belong on the transaction's own
+          # span. That event stays open until the response finishes, so there is
+          # no later point in the request at which these could be set.
+          transaction.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpServerRequest.attributes_for(
+              :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),
+              :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(
+            :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+          )
           request.env[APPSIGNAL_TRANSACTION] = transaction
 
           request.env[RACK_AFTER_REPLY] ||= []
@@ -118,13 +144,27 @@ module Appsignal
 
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
           transaction.finish_event("process_request.rack", "callback: on_finish", "")
-          transaction.add_params_if_nil { request.params }
-          transaction.add_headers_if_nil { request.env }
+          transaction.add_request_payload_if_nil { request.params }
+          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
           queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
           transaction.set_queue_start(queue_start) if queue_start
+          # Describes the response on the transaction's span, which the semantic
+          # conventions ask for whenever a response was sent. It can be set here
+          # because the `process_request.rack` event was finished above, which
+          # leaves the transaction's own span as the one attributes go on.
+          #
+          # Only a response the app actually produced counts. The 500 below
+          # stands in for a status that was never sent, so it is reported as a
+          # tag and a metric but not as this attribute.
+          transaction.add_opentelemetry_attributes(
+            Appsignal::OpenTelemetry::HttpResponse.attributes_for(response&.status)
+          )
           response_status =
             if response
               response.status

data/lib/appsignal/rack/grape_middleware.rb

@@ -7,6 +7,7 @@ module Appsignal
       # @api private
       def initialize(app, options = {})
         options[:instrument_event_name] = "process_request.grape"
+        options[:opentelemetry_scope] = ["appsignal-ruby/grape", Appsignal::VERSION]
         options[:report_errors] = lambda { |env| !env["grape.skip_appsignal_error"] }
         super
       end

data/lib/appsignal/rack/hanami_middleware.rb

@@ -7,6 +7,7 @@ module Appsignal
       def initialize(app, options = {})
         options[:params_method] = nil
         options[:instrument_event_name] ||= "process_action.hanami"
+        options[:opentelemetry_scope] ||= ["appsignal-ruby/hanami", Appsignal::VERSION]
         super
       end
 
@@ -19,7 +20,7 @@ module Appsignal
       def add_transaction_metadata_after(transaction, request)
         action_name = fetch_hanami_action(request.env)
         transaction.set_action_if_nil(action_name) if action_name
-        transaction.add_params { params_for(request) }
+        transaction.add_request_payload { params_for(request) }
       end
 
       def params_for(request)

data/lib/appsignal/rack/instrumentation_middleware.rb

@@ -55,6 +55,7 @@ module Appsignal
     class InstrumentationMiddleware < AbstractMiddleware
       def initialize(app, options = {})
         options[:instrument_event_name] ||= "process_request_middleware.rack"
+        options[:opentelemetry_scope] ||= ["appsignal-ruby/rack", Appsignal::VERSION]
         super
       end
     end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -8,6 +8,7 @@ module Appsignal
         options[:request_class] ||= ActionDispatch::Request
         options[:params_method] ||= :filtered_parameters
         options[:instrument_event_name] = nil
+        options[:opentelemetry_scope] = ["appsignal-ruby/rails", Appsignal::VERSION]
         options[:report_errors] = true
         super
       end

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -33,6 +33,7 @@ module Appsignal
         options[:request_class] ||= Sinatra::Request
         options[:params_method] ||= :params
         options[:instrument_event_name] ||= "process_action.sinatra"
+        options[:opentelemetry_scope] ||= ["appsignal-ruby/sinatra", Appsignal::VERSION]
         super
         @raise_errors_on = raise_errors?(app)
       end

data/lib/appsignal/rack.rb

@@ -7,9 +7,72 @@ module Appsignal
     APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
     APPSIGNAL_EVENT_HANDLER_HAS_ERROR = "appsignal.event_handler.error"
     APPSIGNAL_RESPONSE_INSTRUMENTED = "appsignal.response_instrumentation_active"
+    APPSIGNAL_RESPONSE_STATUS = "appsignal.response_status"
     RACK_AFTER_REPLY = "rack.after_reply"
 
     class Utils
+      # Fetch the HTTP request method from the request.
+      #
+      # The request class is configurable, so reading the method can raise.
+      # Log and return nil in that case, leaving it to the caller to skip
+      # whatever it needed the method for.
+      #
+      # @param request [Rack::Request] Request object.
+      # @return [String, NilClass]
+      def self.request_method_from(request)
+        request.request_method
+      rescue => error
+        Appsignal.internal_logger.error(
+          "Exception while fetching the HTTP request method: #{error.class}: #{error}"
+        )
+        nil
+      end
+
+      # Fetch a value that describes the request, named after the method that
+      # reads it.
+      #
+      # The request class is configurable, so reading from the request can
+      # raise. Log and return nil in that case, leaving it to the caller to skip
+      # whatever it needed the value for.
+      #
+      # @param request [Rack::Request] Request object.
+      # @param name [Symbol] Name of the method that reads the value.
+      # @return [Object, NilClass]
+      def self.request_value_from(request, name)
+        request.public_send(name)
+      rescue => error
+        Appsignal.internal_logger.error(
+          "Exception while fetching the HTTP request #{name}: #{error.class}: #{error}"
+        )
+        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
@@ -53,18 +116,20 @@ module Appsignal
         # TODO: Remove in next major/minor version
         transaction.set_metadata("path", request_path)
 
-        request_method = request_method_for(request)
+        request_method = Appsignal::Rack::Utils.request_method_from(request)
         if request_method
           transaction.set_metadata("request_method", request_method)
           # TODO: Remove in next major/minor version
           transaction.set_metadata("method", request_method)
         end
 
-        transaction.add_params { params_for(request) }
+        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
@@ -84,15 +149,6 @@ module Appsignal
         nil
       end
 
-      def request_method_for(request)
-        request.request_method
-      rescue => error
-        Appsignal.internal_logger.error(
-          "Exception while fetching the HTTP request method: #{error.class}: #{error}"
-        )
-        nil
-      end
-
       def session_data_for(request)
         return unless request.respond_to?(:session)
 

data/lib/appsignal/sample_data.rb

@@ -61,6 +61,10 @@ module Appsignal
       @empty
     end
 
+    # The sample-data category this holds (e.g. `:params`, `:request_payload`).
+    # Used to name the data in log messages.
+    attr_reader :key
+
     protected
 
     attr_reader :blocks

data/lib/appsignal/transaction/base_backend.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Transaction
+    # @!visibility private
+    #
+    # The interface every transaction backend implements. `Appsignal::Backends
+    # .transaction` picks a concrete backend per mode -- ExtensionBackend in
+    # agent mode, OpenTelemetryBackend in collector mode. This base documents the
+    # contract; a backend that leaves a method unimplemented raises here.
+    class BaseBackend
+      # Instrumented events.
+      def start_event(opentelemetry_kind: nil, opentelemetry_scope: nil)
+        raise NotImplementedError
+      end
+
+      def finish_event(_name, _title, _body, _body_format)
+        raise NotImplementedError
+      end
+
+      def record_event( # rubocop:disable Metrics/ParameterLists
+        _name, _title, _body, _body_format, _duration,
+        opentelemetry_kind: nil, opentelemetry_scope: nil
+      )
+        raise NotImplementedError
+      end
+
+      # Transaction metadata.
+      def set_action(_action)
+        raise NotImplementedError
+      end
+
+      def set_namespace(_namespace)
+        raise NotImplementedError
+      end
+
+      def set_metadata(_key, _value)
+        raise NotImplementedError
+      end
+
+      def set_queue_start(_start)
+        raise NotImplementedError
+      end
+
+      # OpenTelemetry span attributes, set on whichever span the backend is
+      # currently recording. Only meaningful in collector mode; agent mode has
+      # no span to hang them on.
+      def set_attributes(_attributes)
+        raise NotImplementedError
+      end
+
+      # Maps each logical params channel (`:params`, `:request_payload`,
+      # `:function_parameters`) to the storage bucket it lands in. Channels that
+      # share a bucket merge into one `SampleData` object on the transaction;
+      # distinct buckets stay separate. The bucket name is also the sample-data
+      # key `set_sample_data` receives for that bucket, so it must be a key this
+      # backend's `set_sample_data` knows how to store.
+      def params_mapping
+        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
+      end
+
+      def add_breadcrumb(_breadcrumb)
+        raise NotImplementedError
+      end
+
+      def set_error(_class_name, _message, _backtrace, _causes, _root_cause_missing)
+        raise NotImplementedError
+      end
+
+      # Whether the backend can hold more than one error on a single
+      # transaction. When it can't (agent mode), the Transaction reports the
+      # extra errors as duplicate transactions instead.
+      def supports_multiple_errors?
+        raise NotImplementedError
+      end
+
+      # Lifecycle.
+      def finish
+        raise NotImplementedError
+      end
+
+      def complete
+        raise NotImplementedError
+      end
+
+      def discard
+        raise NotImplementedError
+      end
+
+      # Only used when `supports_multiple_errors?` is false (agent mode).
+      # Backends that support multiple errors never duplicate and leave this
+      # unimplemented.
+      def duplicate(_new_transaction_id)
+        raise NotImplementedError
+      end
+
+      def to_json # rubocop:disable Lint/ToJSON
+        raise NotImplementedError
+      end
+    end
+  end
+end