brut 0.0.21 → 0.0.23

data/lib/brut/front_end/handlers/csp_reporting_handler.rb

@@ -1,9 +1,12 @@
 # Receives content security policy violations and logs them. This is set up in {Brut::Framework::MCP}, however CSP reporting is
 # configured in {Brut::FrontEnd::RouteHooks::CSPNoInlineStylesOrScripts::ReportOnly}.
 class Brut::FrontEnd::Handlers::CspReportingHandler < Brut::FrontEnd::Handler
-  def handle(body:)
+  def initialize(body:)
+    @body = body
+  end
+  def handle
     begin
-      parsed = JSON.parse(body.read)
+      parsed = JSON.parse(@body.read)
       Brut.container.instrumentation.add_attributes(parsed.merge(prefix: "brut.csp-reporting"))
     rescue => ex
       Brut.container.instrumentation.record_exception(ex)

data/lib/brut/front_end/handlers/instrumentation_handler.rb

@@ -65,12 +65,16 @@ class Brut::FrontEnd::Handlers::InstrumentationHandler < Brut::FrontEnd::Handler
     def as_carrier = { "traceparent" => @value }
   end
 
-  def handle(http_tracestate:, http_traceparent:)
-    traceparent = TraceParent.from_header(http_traceparent)
-    span        = Span.from_header(http_tracestate)
+  def initialize(http_tracestate:, http_traceparent:)
+    @http_tracestate  = http_tracestate
+    @http_traceparent = http_traceparent
+  end
+  def handle
+    traceparent = TraceParent.from_header(@http_traceparent)
+    span        = Span.from_header(@http_tracestate)
 
     if span.nil? || traceparent.nil?
-      SemanticLogger[self.class].info "Missing traceparent or span: #{http_tracestate}, #{http_traceparent}"
+      SemanticLogger[self.class].info "Missing traceparent or span: #{@http_tracestate}, #{@http_traceparent}"
       return http_status(400)
     end
 

data/lib/brut/front_end/handlers/locale_detection_handler.rb

@@ -5,9 +5,13 @@
 # {Brut::FrontEnd::Session#http_accept_language=} *only* if the `Accept-Language` header did not provide a value that is supported by
 # the app.
 class Brut::FrontEnd::Handlers::LocaleDetectionHandler < Brut::FrontEnd::Handler
-  def handle(body:,session:)
+  def initialize(body:,session:)
+    @body    = body
+    @session = session
+  end
+  def handle
     begin
-      parsed = JSON.parse(body.read)
+      parsed = JSON.parse(@body.read)
 
       Brut.container.instrumentation.add_attributes(
         prefix: "brut.locale-detection",
@@ -19,9 +23,9 @@ class Brut::FrontEnd::Handlers::LocaleDetectionHandler < Brut::FrontEnd::Handler
         locale   = parsed["locale"]
         timezone = parsed["timeZone"]
 
-        session.timezone_from_browser = timezone
-        if !session.http_accept_language.known?
-          session.http_accept_language = Brut::I18n::HTTPAcceptLanguage.from_browser(locale)
+        @session.timezone_from_browser = timezone
+        if !@session.http_accept_language.known?
+          @session.http_accept_language = Brut::I18n::HTTPAcceptLanguage.from_browser(locale)
         end
       end
     rescue => ex

data/lib/brut/front_end/handlers/missing_handler.rb

@@ -1,7 +1,10 @@
 # Used in development to handle a defined route but a missing page. This arranges to render a nicer error page than the default.
 class Brut::FrontEnd::Handlers::MissingHandler < Brut::FrontEnd::Handler
-  def handle(route:)
-    Brut::FrontEnd::Pages::MissingPage.new(route:)
+  def initialize(route:)
+    @route = route
+  end
+  def handle
+    Brut::FrontEnd::Pages::MissingPage.new(route: @route)
   end
 
   class Form < Brut::FrontEnd::Form

data/lib/brut/front_end/page.rb

@@ -35,12 +35,12 @@ class Brut::FrontEnd::Page < Brut::FrontEnd::Component
   # redirect the user or produce an error.
   #
   # @return [URI|Brut::FrontEnd::HttpStatus|Object] If you return a `URI` (mostly likely by returning the result of calling {Brut::FrontEnd::HandlingResults#redirect_to}), the user is redirected and no HTML is generated. If you return a {Brut::FrontEnd::HttpStatus} (mostly likely by returning the result of calling {Brut::FrontEnd::HandlingResults#http_status}), HTML generation is skipped and that status is returned with no content.  If anything else is returned, HTML is generated normal.
-  def before_render = nil
+  def before_generate = nil
 
-  # Core method of this class. Do not override. This handles the use of {#before_render} and is what Brut
+  # Core method of this class. Do not override. This handles the use of {#before_generate} and is what Brut
   # calls to possibly render the page.
   def handle!
-    case before_render
+    case before_generate
     in URI => uri
       uri
     in Brut::FrontEnd::HttpStatus => http_status
@@ -72,9 +72,6 @@ class Brut::FrontEnd::Page < Brut::FrontEnd::Component
   # Convienience method for {.page_name}.
   def page_name = self.class.page_name
 
-  # @!visibility private
-  def component_name = raise Brut::Framework::Errors::Bug,"#{self.class} is not a component"
-
 private
 
   # Locates the layout class and uses it to render itself, along
@@ -88,6 +85,7 @@ private
         "layout"
       ].join("_")).camelize
     )
+    Brut.container.instrumentation.add_prefixed_attributes("brut", layout_class: layout_class)
     render layout_class.new(page_name:,&block)
   end
 

data/lib/brut/front_end/request_context.rb

@@ -112,12 +112,13 @@ class Brut::FrontEnd::RequestContext
   # @param [Class] klass a class that is to be instantiated entirely by the contents of this `RequestContext`.
   # @param [Hash] request_params Query string parameters provided by Rack.
   # @param [Brut::FrontEnd::Routing::Route] route the route that triggered the request.
+  # @param [Brut::FrontEnd::Form] form the form, if available
   # @return [Hash] can be splatted to keyword arguments and passed to the constructor of `klass`
   #
   # @raise [ArgumentError] if the constructor has any non-keyword arguments, or if any required keyword argument is
   #                        not present in this `RequestContext`.
-  def as_constructor_args(klass, request_params:, route:nil)
-    args_for_method(method: klass.instance_method(:initialize), request_params:, form: nil, route:)
+  def as_constructor_args(klass, request_params:, route:nil, form: nil)
+    args_for_method(method: klass.instance_method(:initialize), request_params:, form: , route:)
   end
 
   # Based on `object`' method, returns a Hash that maps all keywords it requires to the values stored in this

data/lib/brut/i18n/base_methods.rb

@@ -6,43 +6,66 @@
 # * {Brut::I18n::ForCLI} for CLI apps
 # * {Brut::I18n::ForBackEnd} for back-end classes that aren't generating HTML
 #
+# This module assumes the existence of a three-method protocol that's used for HTML escaping in an
+# HTML-generating web context:
+#
+# * `capture` accepts the block yieled to {#t} and returns whatever it generates.  This needs to exist
+#   because Phlex's API renders to an internal buffer by default.  This module needs to allow Phlex
+#   API methods to render to a different buffer.
+# * `safe` accepts a string and returns a string that is presumed to be HTML safe.
+# * `html_escape` accepts a string and returns a string that is HTML escaped.
+#
+# This module does not implement these methods and assumes that either the class using this module will
+# implement them or that a submodule being used does.  All submodules provided by Brut provide implementations,
+# so this information is only relevant if you are using this module directly.
 module Brut::I18n::BaseMethods
 
   # Access a translation and insert interpolated elemens as needed. This will use the provided key to determine
-  # the actual full key to the translation, as described below.  The value returned is not HTML escaped,
-  # assuming that you have not placed HTML injections in your own translation files.  Interpolated
-  # values *are* HTML escaped, so external input is safe to provide.
-  #
-  # This method also may take a block, and the results of the block are inserted into the `%{block}`
-  # interpolation value in the i18n string, if it's present.
+  # the actual full key to the translation, as described below. See {Brut::I18n::ForHTML#t} for details
+  # on how this works in the context of a {Brut::FrontEnd::Component} or {Brut::FrontEnd::Page}.
   #
   # Any missing interpolation will result in an exception, *except* for the value `field`. When
   # a string has `%{field}` in it, but `field:` is omitted in this call, the value for 
-  # `"general.cv.this_field"` is used. This value, in English, is "this field", so a call
+  # `"cv.this_field"` is used. This value, in English, is "this field", so a call
   # to `t("email.required")` would generate `"This field is required"`, while a call
   # to `t("email.required", field: "E-mail address")` would generate `"E-mail address is required"`.
   #
   # @param [String,Symbol,Array<String>,Array<Symbol>] key used to create one or more keys to be translated.
-  #        This value's behavior is designed to balance predictabilitiy in what actual key is chosen
-  #        but without needless repetition on a page.  If this value is provided, and is an array, the values
-  #        are joined with "." to form a key.  If the value is not an array, that value is used directly.
-  #        Given this key, two values are checked for a translation: the key itself and 
-  #        the key inside "general.".  If this value is *not* provided, it is expected
-  #        that the `**rest` hash includes page: or component:.  See that parameter and the example.
-  #
-  # @param [Hash] rest values to use for interpolation of the key's translation. If `key` is omitted,
-  #               this hash should have a value for either `page:` or `component:` (not both).  If
-  #               `page:` is present, it is assumed that the class that has included this module
-  #               is a `Brut::FrontEnd::Page` or is a page component.  It's `page_name` will be used to create
-  #               a key based on the value of `page:`: `pages.«page_name».«page: value»`.
-  #               if `component:` is included, the behavior is the same but for `component` instead of `page`.
-  #               Note that if the page– or component–specific key is not found, this will check
-  #               `general.«page: value»`.
+  #        This value's behavior balances predictabilitiy with what key is used and some flexibilty
+  #        to allow page– or component–specific translations when needed, and fallbacks when not.
+  #
+  #        When an array if given, the values are turned into strings and joined with a "." to
+  #        form a full key.
+  #
+  #        Depending on what class this module is mixed into, additional keys will be tried:
+  #
+  #        * If this is a page, `pages.«page_name».` will be prepended and tried before the key passed in.
+  #          If the `pages.«page_name»` version is not found, the exact key passed in is checked.
+  #        * If this is a page private component, `pages.«page_name».` will be prepended and tried before
+  #          the key passed in. The value for `«page_name»` is determined by the outer class that this
+  #          component is a part of.
+  #        * If this is a component (include if it is a page private component),
+  #          `components.«component_name».` will be prepended and tried before the key passed in.
+  #          If the `components.«component_name»` version is not found, the exact key passed in is checked.
+  #
+  #        The priority of the keys are as follows:
+  #
+  #        1. Component key is checked (unless this is a page)
+  #        2. Page key is checked (unless this is a non-page private component)
+  #        3. The literal key passed-in is checked
+  #
+  #        If no value is found for any key an exception is raised.
+  #
+  # @param [Hash] interpolated_values values to use for interpolation of the key's translation. Note that if
+  #        `:block` is part of this has, you may not pass a block to this method.  Note also
+  #        that `:count` can be used if the key is expected to be pluralized.  This value
+  #        is required for keys that are designed for pluralization. See examples below.
   # @option interpolated_values [Numeric] count Special interpolation to control pluralization.
-  # @yield Nothing is yielded if a block is given, however the value returned is used for the `%{block}`
-  #        interpolation value.
+  # @option interpolated_values [String] block Value to use for `%{block}`. If this is used, a block may not be
+  #                             yielded.
+  # @yield If a block is passed, it is used for the value of `%{block}`. No parameters are yielded to the block.
   # @yieldreturn [String] The value to use for the `%{block}` interpolation value.  There is some nuance to
-  #                       how this works.  The value returned is given to `capture`, and that value
+  #                       how this works.  The value returned is given to `capture`, and *that* value
   #                       is given to `safe`.  Outside of an HTML-rendering context, these methods
   #                       simply pass through the contents of the block.  In an HTML-rendering
   #                       context, however, these methods are assumed to be from
@@ -57,25 +80,17 @@ module Brut::I18n::BaseMethods
   # @example Simplest usage
   #   # in your translations file
   #   en: {
-  #     general: {
-  #       hello: "Hi!"
-  #     },
-  #     formalized: {
-  #       hello: "Greetings!"
-  #     }
+  #     hello: "Hi!"
   #   }
   #   # in your code
   #   t(:hello) # => Hi!
-  #   t("formalized.hello") # => Greetings!
   #
   # @example Using an array for the key
   #   # in your translations file
   #   en: {
-  #     general: {
-  #       actions: {
-  #         edit: "Make an edit"
-  #       }
-  #     },
+  #     actions: {
+  #       edit: "Make an edit"
+  #     }
   #   }
   #   # in your code
   #   t([:actions, :edit]) # => Make an edit
@@ -83,9 +98,7 @@ module Brut::I18n::BaseMethods
   # @example Using page:
   #   # in your translations file
   #   en: {
-  #     general: {
-  #       new_widget: "Make a New Widget",
-  #     },
+  #     new_widget: "Make a New Widget",
   #     pages: {
   #       HomePage: {
   #         new_widget: "Create new Widget"
@@ -96,28 +109,61 @@ module Brut::I18n::BaseMethods
   #     },
   #   }
   #   # in your code for HomePage
-  #   t(page: :new_widget) # => Create new Widget
+  #   t(:new_widget) # => Create new Widget
   #   # in your code for WidgetsPage
-  #   t(page: :new_widget) # => Create New
+  #   t(:new_widget) # => Create New
   #   # in your code for SomeOtherPage
-  #   t(page: :new_widget) # => Make a New Widget
+  #   t(:new_widget) # => Make a New Widget
   #
-  # @example Using page: with an array
+  # @example Using in a component
   #   # in your translations file
   #   en: {
+  #     status: {
+  #       ready: "Available",
+  #       stalled: "Stalled",
+  #       completed: "Done",
+  #     },
+  #     components: {
+  #       TagComponent: {
+  #         status: {
+  #           ready: "Ready",
+  #           stalled: "Waiting",
+  #         }
+  #       },
+  #     },
+  #   }
+  #   # in your code for TagComponent
+  #   t(page: [ :status, :ready ]) # => Ready
+  #   t(page: [ :status, :completed ]) # => Done
+  #   # in your code for StatusComponent
+  #   t(page: [ :status, :ready ]) # => Available
+  #   t(page: [ :status, :completed ]) # => Done
+  #
+  # @example Using in a page-private component
+  #   # in your translations file
+  #   en: {
+  #     status: {
+  #       ready: "Available",
+  #       stalled: "Stalled",
+  #       completed: "Done",
+  #     },
   #     pages: {
   #       WidgetsPage: {
-  #         new_widget: "Create New"
-  #         captions: {
-  #           new: "New Widgets"
-  #         }
+  #         new_widget: "Create New",
+  #         nevermind: "Don't Create One",
+  #       },
+  #     }
+  #     components: {
+  #       "WidgetsPage::WidgetComponent": {
+  #         new_widget: "Make New Widget",
   #       },
   #     },
   #   }
-  #   # in your code for HomePage
-  #   t(page: [ :captions, :new ]) # => New Widgets
+  #   # in your code for WidgetsPage::WidgetComponent
+  #   t(page: :new_widget) # => Make New Widget
+  #   t(page: :nevermind) # => Don't Create One
   #
-  # @example Using a block with Phlex
+  # @example Using a block in a page or component
   #   # in your translations file
   #   en: {
   #     greeting: "Hello there %{name}, you may %{block}",
@@ -140,42 +186,35 @@ module Brut::I18n::BaseMethods
   #       contact support
   #     </a>
   #   </h1>
-  def t(key=:look_in_rest,**rest,&block)
-    if key == :look_in_rest
-
-      page      = rest.delete(:page)
-      component = rest.delete(:component)
+  def t(key,**interpolated_values,&block)
+    keys_to_check = []
+    key = Array(key).join('.')
+    is_page_private_component = self.kind_of?(Brut::FrontEnd::Component) &&
+                                self.page_private?
+    is_page                   = self.kind_of?(Brut::FrontEnd::Page)
+    is_component              = self.kind_of?(Brut::FrontEnd::Component) && !is_page
 
-      if !page.nil? && !component.nil?
-        raise ArgumentError, "You may only specify page or component, not both"
-      end
-
-      subkey = nil
-      if page
-        subkey = Array(page).join(".")
-        key = ["pages.#{self.page_name}.#{subkey}"]
-      elsif component
-        subkey = Array(component).join(".")
-        key = ["components.#{self.component_name}.#{subkey}"]
-      else
-        raise ArgumentError, "If you omit an explicit key, you must specify page or component"
-      end
-      key << "general.#{subkey}"
-    else
-      key = Array(key).join('.')
-      key = [key,"general.#{key}"]
+    if is_component
+      keys_to_check << "components.#{self.component_name}.#{key}"
     end
+    if is_page
+      keys_to_check << "pages.#{self.page_name}.#{key}"
+    elsif is_page_private_component
+      keys_to_check << "pages.#{self.containing_page_name}.#{key}"
+    end
+    keys_to_check << key
+
     if !block.nil?
-      if rest[:block]
+      if interpolated_values[:block]
         raise ArgumentError,"t was given a block and a block: param. You can't do both "
       end
       block_contents = safe(capture(&block))
-      rest[:block] = block_contents
+      interpolated_values[:block] = block_contents
     end
-    t_direct(key,**rest)
+    t_direct(keys_to_check,**interpolated_values.merge(key_given: key))
   rescue I18n::MissingInterpolationArgument => ex
     if ex.key.to_s == "block"
-      raise ArgumentError,"One of the keys #{key.join(", ")} contained a %{block} interpolation value: '#{ex.string}'. This means you must use t_html *and* yield a block to it"
+      raise ArgumentError,"One of the keys #{key.join(", ")} contained a %{block} interpolation value: '#{ex.string}'. This means you must yield a block to `t`"
     else
       raise
     end
@@ -186,7 +225,7 @@ module Brut::I18n::BaseMethods
   end
 
   def this_field_value
-    @__this_field_value ||= ::I18n.t("general.cv.this_field", raise: true)
+    @__this_field_value ||= ::I18n.t("cv.this_field", raise: true)
   end
 
   # Directly access translations without trying to be smart about deriving the key.  This is useful
@@ -194,28 +233,43 @@ module Brut::I18n::BaseMethods
   #
   # @param [Array<String>,Array<Symbol>] keys list of keys representing what is to be translated. The
   #                                           first key found will be used. If no key in the list is found
-  #                                           will raise a I18n::MissingTranslation
+  #                                           will raise a I18n::MissingTranslation. 
   # @param [Hash] interpolated_values value to use for interpolation of the key's translation
   # @option interpolated_values [Numeric] count Special interpolation to control pluralization.
+  # @option interpolated_values [String|Symbol] key_given If included, this is not used for interpolation, but
+  #                                             will be used in error messages to represent the key
+  #                                             given to `t`.
   #
   # @raise [I18n::MissingTranslation] if no translation is found
   # @raise [I18n::MissingInterpolationArgument] if interpolation arguments are missing, or if the key
   #                                             has pluralizations and no count: was given
   def t_direct(keys,interpolated_values={})
     keys = Array(keys).map(&:to_sym)
+    key_given = interpolated_values.delete(:key_given)
     default_interpolated_values = {
       field: this_field_value,
     }
     escaped_interpolated_values = interpolated_values.map { |key,value|
       if value.kind_of?(String)
-        [ key, CGI.escapeHTML(value) ]
+        [ key, html_escape(value) ]
       else
         [ key, value ]
       end
     }.to_h
     result = ::I18n.t(keys.first, default: keys[1..-1],raise: true, **default_interpolated_values.merge(escaped_interpolated_values))
     if result.kind_of?(Hash)
-      raise I18n::MissingInterpolationArgument.new(:count,interpolated_values,keys.join(","))
+      incorrect_pluralization = result.keys.none? { |key| key == :one }
+      if incorrect_pluralization
+        key_message = if key_given
+                        "Key '#{key_given}'"
+                      else
+                        "One of the keys"
+                      end
+        raise Brut::Framework::Errors::Bug,
+          "#{key_message} resulted in a Hash that doesn't appear to be created for pluralizations. This means that you may have given a key expecting it to map to a translation but it is actually a namespace for other keys.  Please adjust your translations file to avoid this situation. Keys checked:\n#{keys.join(", ")}\nSub keys found:\n#{result.keys.join(', ')}"
+      else
+        raise I18n::MissingInterpolationArgument.new(:count,interpolated_values,keys.join(","))
+      end
     end
     result
   end

data/lib/brut/i18n/for_back_end.rb

@@ -5,4 +5,5 @@ module Brut::I18n::ForBackEnd
   include Brut::I18n::BaseMethods
   def safe(string) = string
   def capture(&block) = block.()
+  def html_escape(value) = value
 end

data/lib/brut/i18n/for_cli.rb

@@ -5,4 +5,5 @@ module Brut::I18n::ForCLI
   include Brut::I18n::BaseMethods
   def safe(string) = string
   def capture(&block) = block.()
+  def html_escape(value) = value
 end

data/lib/brut/i18n/for_html.rb

@@ -1,12 +1,40 @@
 # I18n for components or pages, which are assumed to be Phlex components.
-# To use this outside of a Phlex context, you must define these two
-# methods to ensure proper HTML escaping happens:
+# This will do HTML escaping as follows:
+#
+# * Interpolated values are always HTML-escaped
+# * When a block is used, that value is assumed to be safe HTML,
+#   and generated outside the current Phlex context. It's value is
+#   captured (via `#capture`) and then declared HTML safe by being
+#   passed to `#safe`.
+#
+# Unless you put HTML injections into your translations file, this should result
+# in safe HTML in any translation.
+#
+# This module provides two features that aren't part of {#Brut::I18n::BaseMethods}:
+#
+# * {#t} calls `#safe` on its return value, indicating that the string is safe. To use
+#   this string in a Phlex view, you *must* call `#raw` and pass it the string.
+# * {#html_escape} is implemented to escape values it's given.
+#
+#
+# @example
+#   class StatusComponent < AppComponent
+#     def initialize(status:)
+#       @status = status
+#     end
+#     def view_template
+#       div do
+#         raw(
+#           t( [ :status, @status ] )
+#         )
+#       end
+#     end
+#   end
 #
-# * `safe` to accept a string and return a string.
-# * `capture` to accept a block and return its contents as a string.
 module Brut::I18n::ForHTML
   include Brut::I18n::BaseMethods
   def t(...)
     safe(super)
   end
+  def html_escape(value) = CGI.escapeHTML(value)
 end

data/lib/brut/instrumentation/open_telemetry.rb

@@ -63,7 +63,7 @@ class Brut::Instrumentation::OpenTelemetry
   # @param [Exception] ex the exception to record.
   # @param [Hash] attributes any attributes to attach that will show up in your OTel provider
   # @raise [Exception] the exception passed in.
-  def record_and_reraise_exception(ex,attributes=nil)
+  def record_and_reraise_exception!(ex,attributes=nil)
     reecord_exception(ex,attributes)
     raise ex
   end
@@ -71,13 +71,23 @@ class Brut::Instrumentation::OpenTelemetry
 
   # Adds attributes to the span, converting the hash or keyword arguments to strings. This will use
   # the app's Otel prefix for all attributes, so you do not have to prefix them.
-  # If you need to set standard attributes, you should use {Brut::Instrumentation::OpenTelemetry::Span#add_prefixed_attributes} instead.
+  # If you need to set standard attributes, you should use {#add_prefixed_attributes} instead.
   # @param [Hash] attributes any attributes to attach to the event.
   def add_attributes(attributes)
     current_span = OpenTelemetry::Trace.current_span
     current_span.add_attributes(NormalizedAttributes.new(:detect,attributes).to_h)
   end
 
+  # Adds attributes to the span, prefixing each key with the given prefix, then converting the hash or keyword arguments to strings.  For example, if the prefix is 'my_app' and you add the attributes 'type' and 'reason', the actual attribute names will be 'my_app.type' and 'my_app.reason'.
+  #
+  # @see #add_attributes
+  def add_prefixed_attributes(prefix,attributes)
+    current_span = OpenTelemetry::Trace.current_span
+    current_span.add_attributes(
+      NormalizedAttributes.new(prefix,attributes).to_h
+    )
+  end
+
 private
 
   class NormalizedAttributes

data/lib/brut/sinatra_helpers.rb

@@ -179,16 +179,23 @@ module Brut::SinatraHelpers
             form_class: form_class,
           )
 
-          handler = handler_class.new
           form = if form_class.nil?
                    nil
                  else
                    form_class.new(params: params)
                  end
 
-          process_args = Brut::FrontEnd::RequestContext.current.as_method_args(handler,:handle,request_params: params,form: form,route:brut_route)
+          constructor_args = Brut::FrontEnd::RequestContext.current.as_constructor_args(
+            handler_class,
+            request_params: params,
+            route: brut_route,
+            form: form,
+          )
+
+          handler = handler_class.new(**constructor_args)
 
-          result = handler.handle!(**process_args)
+          result = handler.handle!
+          span.add_prefixed_attributes("brut", result_class: result.class)
 
           case result
           in URI => uri