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

data/lib/appsignal/opentelemetry.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require "appsignal/opentelemetry/attributes"
+require "appsignal/opentelemetry/dependencies"
+require "appsignal/opentelemetry/error_type"
+require "appsignal/opentelemetry/http_client_request"
+require "appsignal/opentelemetry/http_method"
+require "appsignal/opentelemetry/http_response"
+require "appsignal/opentelemetry/http_server_request"
+require "appsignal/opentelemetry/messaging"
+require "appsignal/opentelemetry/rendering"
+require "appsignal/opentelemetry/sql_db_system"
+
+module Appsignal
+  # @!visibility private
+  module OpenTelemetry
+    class << self
+      # Configure the global OpenTelemetry SDK to export OTLP/HTTP protobuf to
+      # the collector endpoint in `config[:collector_endpoint]`.
+      #
+      # The SDK and exporter gems are required lazily, so an application not in
+      # collector mode does not pay the load cost. Sets `@started`, which
+      # {.started?} reads to decide whether to route through the OTel backends.
+      def configure(config)
+        # The OTel Ruby SDK exposes no programmatic knob for the default
+        # aggregation temporality; this env var is the only way to set
+        # it. We pick `:delta` to match the Python integration. (Note:
+        # the Ruby SDK keeps `UpDownCounter` cumulative regardless of
+        # this preference, per the OTel spec.)
+        ENV["OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE"] ||= "delta"
+
+        # With the metrics and logs SDK gems loaded, `SDK.configure` below
+        # auto-installs a metrics reader and a log processor from these env vars,
+        # each with its own background thread. Both providers are replaced right
+        # after, which would leave those threads running and unreachable by any
+        # shutdown. Set unconditionally, so a user-set "otlp" cannot slip past
+        # and reintroduce them.
+        ENV["OTEL_METRICS_EXPORTER"] = "none"
+        ENV["OTEL_LOGS_EXPORTER"] = "none"
+
+        require_sdk_gems
+
+        # The OpenTelemetry gems are optional and installed by the user (not
+        # declared in the gemspec). If they're present but older than the
+        # versions we support, fall back to the agent rather than booting an
+        # SDK that may misbehave (e.g. a metrics SDK without fork hooks).
+        return unless required_gem_versions_met?
+
+        endpoint = config[:collector_endpoint].to_s.sub(%r{/+\z}, "")
+        # Merge with the SDK's default resource so all three signal types
+        # carry the same `telemetry.sdk.*` and `process.*` attributes that
+        # `SDK.configure` would have added on its own. `MeterProvider` and
+        # `LoggerProvider` take a `resource:` kwarg that replaces (not
+        # merges), so we do the merge ourselves and use the same merged
+        # resource for the tracer provider to keep all three in sync.
+        resource = ::OpenTelemetry::SDK::Resources::Resource.default.merge(build_resource(config))
+
+        ::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"
+              )
+            )
+          )
+        end
+
+        # Wrap the OTLP MetricsExporter in a PeriodicMetricReader so that
+        # `MeterProvider#force_flush` actually triggers an export. The OTLP
+        # exporter itself is also a MetricReader but its inherited
+        # `force_flush` is a no-op.
+        ::OpenTelemetry.meter_provider =
+          ::OpenTelemetry::SDK::Metrics::MeterProvider.new(:resource => resource)
+        ::OpenTelemetry.meter_provider.add_metric_reader(
+          ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+            :exporter => ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.new(
+              :endpoint => "#{endpoint}/v1/metrics"
+            )
+          )
+        )
+
+        ::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"
+            )
+          )
+        )
+
+        @started = true
+      rescue LoadError => e
+        @started = false
+        Appsignal::Utils::StdoutAndLoggerMessage.error(
+          "Cannot configure OpenTelemetry SDK for collector mode: #{e.class}: #{e.message}"
+        )
+      rescue => e
+        @started = false
+        Appsignal::Utils::StdoutAndLoggerMessage.error(
+          "Error configuring OpenTelemetry SDK for collector mode: " \
+            "#{e.class}: #{e.message}\n#{e.backtrace&.join("\n")}"
+        )
+      end
+
+      # Whether {.configure} has successfully booted the OpenTelemetry SDK
+      # for this process. Returns `false` before {.configure} runs and
+      # `false` if it ran but raised.
+      def started?
+        defined?(@started) ? @started : false
+      end
+
+      # Write the current trace context onto an outgoing carrier (HTTP request,
+      # job hash, ...) with the configured propagator, so a downstream service
+      # joins the same trace.
+      #
+      # A no-op unless the SDK has booted. The carrier is injected from whatever
+      # span is current at call time, which inside an `Appsignal.instrument`
+      # block is the event's own span.
+      def inject_context(carrier)
+        if_started do
+          ::OpenTelemetry.propagation.inject(carrier)
+        end
+      end
+
+      # Read the trace context off an incoming Rack request env using the
+      # globally configured propagator, so an AppSignal transaction created for
+      # the request can continue the upstream trace. Returns an
+      # `OpenTelemetry::Context` (its current span is the remote parent), or
+      # `nil` when the SDK has not booted -- outside collector mode there is
+      # nothing to continue. `rack_env_getter` reads the `HTTP_*`-mangled header
+      # names Rack puts in the env.
+      def extract_rack_context(env)
+        if_started do
+          # Extract onto an empty context, not `Context.current`. The W3C
+          # extractor returns its base context unchanged when the carrier has no
+          # `traceparent`, so a request with no incoming context would inherit
+          # whatever span is ambient on the fiber. Starting empty means "no
+          # carrier" yields no parent, and the transaction starts its own trace.
+          ::OpenTelemetry.propagation.extract(
+            env,
+            :context => ::OpenTelemetry::Context.empty,
+            :getter => ::OpenTelemetry::Common::Propagation.rack_env_getter
+          )
+        end
+      end
+
+      # Read the trace context off an incoming background job hash, so the
+      # transaction can link back to the enqueuer. Returns an
+      # `OpenTelemetry::Context`, or `nil` when the SDK has not booted.
+      #
+      # Reads both carriers a job can arrive with: top-level `traceparent` and
+      # `tracestate` keys, as OpenTelemetry's Sidekiq instrumentation injects
+      # them, and a nested `__otel_headers`, as its Active Job one does. Active
+      # Job puts that through its argument serializer, so it can arrive as an
+      # array of pairs rather than a hash. The nested keys win, being the more
+      # specific layer.
+      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)
+          # 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
+          # span left on the fiber. Otherwise the job's transaction would link
+          # back to an unrelated leaked span instead of standing on its own.
+          ::OpenTelemetry.propagation.extract(
+            carrier,
+            :context => ::OpenTelemetry::Context.empty
+          )
+        end
+      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.
+      #
+      # This is the gate every integration's OTel-specific work goes through, so
+      # integration-specific carrier/getter/setter logic lives in the
+      # integration rather than as a bespoke helper here.
+      def if_started
+        return unless started?
+
+        yield
+      end
+
+      # @!visibility private
+      #
+      # Test-only. Drops the started flag so subsequent tests start from a
+      # clean slate; does not touch the global `::OpenTelemetry` providers.
+      def reset!
+        @started = false
+      end
+
+      # Flush and shut down the OpenTelemetry SDK providers booted by
+      # {.configure}. Called from `Appsignal.stop` so buffered
+      # metrics/logs/spans don't get dropped on exit.
+      def shutdown
+        return unless started?
+
+        ::OpenTelemetry.tracer_provider&.shutdown
+        ::OpenTelemetry.meter_provider&.shutdown
+        ::OpenTelemetry.logger_provider&.shutdown
+      rescue => e
+        Appsignal.internal_logger.error(
+          "Error shutting down OpenTelemetry SDK: #{e.class}: #{e.message}"
+        )
+      end
+
+      # 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.
+      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]
+        host_name = config[:hostname].to_s.empty? ? "unknown" : config[:hostname]
+
+        attrs = {
+          "appsignal.config.name" => config[:name],
+          "appsignal.config.environment" => config.env,
+          "appsignal.config.push_api_key" => config[:push_api_key],
+          "appsignal.config.revision" => revision,
+          "appsignal.config.language_integration" => "ruby",
+          "service.name" => service_name,
+          "host.name" => host_name,
+          "appsignal.config.filter_attributes" => config[:filter_attributes],
+          "appsignal.config.filter_function_parameters" => config[:filter_function_parameters],
+          "appsignal.config.filter_request_query_parameters" =>
+            config[:filter_request_query_parameters],
+          "appsignal.config.filter_request_payload" => config[:filter_request_payload],
+          "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_namespaces" => config[:ignore_namespaces],
+          "appsignal.config.response_headers" => config[:response_headers],
+          "appsignal.config.request_headers" => config[: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?) }
+        ::OpenTelemetry::SDK::Resources::Resource.create(attrs)
+      end
+
+      private
+
+      # 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.
+      def otel_header_pairs?(value)
+        value.is_a?(Array) && value.all? { |pair| pair.is_a?(Array) && pair.size == 2 }
+      end
+
+      # The optional OpenTelemetry gems, required lazily so users not in
+      # collector mode don't pay the load cost. A missing gem raises LoadError,
+      # caught by {.configure}.
+      def require_sdk_gems
+        require "opentelemetry/sdk"
+        require "opentelemetry-common"
+        require "opentelemetry/exporter/otlp"
+        require "opentelemetry-metrics-sdk"
+        require "opentelemetry-exporter-otlp-metrics"
+        require "opentelemetry-logs-sdk"
+        require "opentelemetry-exporter-otlp-logs"
+      end
+
+      # Checks the installed OpenTelemetry gem versions against {REQUIRED_GEMS}.
+      # On a shortfall, warns and flags the SDK as not started so the caller
+      # falls back to the agent; returns whether all requirements are met.
+      def required_gem_versions_met?
+        incompatible = incompatible_gems
+        return true if incompatible.nil?
+
+        @started = false
+        Appsignal::Utils::StdoutAndLoggerMessage.warning(
+          collector_gems_warning(incompatible)
+        )
+        false
+      end
+
+      # Builds the warning shown when the OpenTelemetry gems collector mode needs
+      # are not all installed at a supported version. `incompatible` describes
+      # the gems that are installed but at a version we do not support.
+      #
+      # The message always recommends the `appsignal-opentelemetry` gem, which
+      # installs the whole set. It only lists gems when some are installed at an
+      # incompatible version, because that usually means a constraint in the
+      # bundle that the gem cannot override on its own.
+      def collector_gems_warning(incompatible)
+        message =
+          "AppSignal collector mode requires a set of OpenTelemetry gems. " \
+            "Add the `appsignal-opentelemetry` gem to your bundle to install " \
+            "them. The AppSignal agent will be used instead."
+
+        unless incompatible.empty?
+          message += "\n\nThese installed OpenTelemetry gems are not compatible " \
+            "with this AppSignal version. Update them or remove a version " \
+            "constraint:\n"
+          message += incompatible.map { |line| "- #{line}" }.join("\n")
+        end
+
+        message
+      end
+
+      # Checks the installed OpenTelemetry gems against {REQUIRED_GEMS}. Returns
+      # `nil` when every required gem is installed at a supported version.
+      # Otherwise returns the descriptions of gems that are installed but at a
+      # version we do not support. That list is empty when the only problem is
+      # that some required gems are not installed at all.
+      def incompatible_gems
+        missing = false
+        incompatible = []
+
+        REQUIRED_GEMS.each do |name, constraints|
+          spec = Gem.loaded_specs[name]
+          requirement = Gem::Requirement.new(*constraints)
+
+          if spec.nil?
+            missing = true
+          elsif !requirement.satisfied_by?(spec.version)
+            incompatible << "#{name} #{spec.version} (requires #{requirement})"
+          end
+        end
+
+        return nil if !missing && incompatible.empty?
+
+        incompatible
+      end
+    end
+  end
+end

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,45 @@ 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)
+          )
+        )
+      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 +132,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 +145,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,30 @@ 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)
+            )
+          )
+          transaction.start_event(
+            :opentelemetry_scope => ["appsignal-ruby/rack", Appsignal::VERSION]
+          )
           request.env[APPSIGNAL_TRANSACTION] = transaction
 
           request.env[RACK_AFTER_REPLY] ||= []
@@ -118,13 +140,24 @@ 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_request_payload_if_nil { request.params }
           transaction.add_headers_if_nil { request.env }
           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