good_job 2.1.0 → 2.4.0

data/engine/app/controllers/good_job/cron_schedules_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module GoodJob
+  class CronSchedulesController < GoodJob::BaseController
+    def index
+      configuration = GoodJob::Configuration.new({})
+      @cron_schedules = configuration.cron
+    end
+  end
+end

data/engine/app/controllers/good_job/executions_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module GoodJob
+  class ExecutionsController < GoodJob::BaseController
+    def index
+      @filter = ExecutionsFilter.new(params)
+    end
+
+    def destroy
+      deleted_count = GoodJob::Execution.where(id: params[:id]).delete_all
+      message = deleted_count.positive? ? { notice: "Job execution deleted" } : { alert: "Job execution not deleted" }
+      redirect_back fallback_location: root_path, **message
+    end
+  end
+end

data/engine/app/controllers/good_job/jobs_controller.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 module GoodJob
   class JobsController < GoodJob::BaseController
-    def destroy
-      deleted_count = GoodJob::Job.where(id: params[:id]).delete_all
-      message = deleted_count.positive? ? { notice: "Job deleted" } : { alert: "Job not deleted" }
-      redirect_to root_path, **message
+    def index
+      @filter = JobsFilter.new(params)
+    end
+
+    def show
+      @executions = GoodJob::Execution.active_job_id(params[:id])
+                                      .order(Arel.sql("COALESCE(scheduled_at, created_at) DESC"))
+      redirect_to root_path, alert: "Executions for Active Job #{params[:id]} not found" if @executions.empty?
     end
   end
 end

data/engine/app/filters/good_job/base_filter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module GoodJob
+  class BaseFilter
+    attr_accessor :params
+
+    def initialize(params)
+      @params = params
+    end
+
+    def records
+      after_scheduled_at = params[:after_scheduled_at].present? ? Time.zone.parse(params[:after_scheduled_at]) : nil
+
+      filtered_query.display_all(
+        after_scheduled_at: after_scheduled_at,
+        after_id: params[:after_id]
+      ).limit(params.fetch(:limit, 25))
+    end
+
+    def last
+      @_last ||= records.last
+    end
+
+    def job_classes
+      base_query.group("serialized_params->>'job_class'").count
+                .sort_by { |name, _count| name }
+                .to_h
+    end
+
+    def queues
+      base_query.group(:queue_name).count
+                .sort_by { |name, _count| name }
+                .to_h
+    end
+
+    def states
+      raise NotImplementedError
+    end
+
+    def to_params(override)
+      {
+        state: params[:state],
+        job_class: params[:job_class],
+      }.merge(override).delete_if { |_, v| v.nil? }
+    end
+
+    def chart_data
+      count_query = Arel.sql(GoodJob::Execution.pg_or_jdbc_query(<<~SQL.squish))
+        SELECT *
+        FROM generate_series(
+          date_trunc('hour', $1::timestamp),
+          date_trunc('hour', $2::timestamp),
+          '1 hour'
+        ) timestamp
+        LEFT JOIN (
+          SELECT
+              date_trunc('hour', scheduled_at) AS scheduled_at,
+              queue_name,
+              count(*) AS count
+            FROM (
+              #{filtered_query.except(:select).select('queue_name', 'COALESCE(good_jobs.scheduled_at, good_jobs.created_at)::timestamp AS scheduled_at').to_sql}
+            ) sources
+            GROUP BY date_trunc('hour', scheduled_at), queue_name
+        ) sources ON sources.scheduled_at = timestamp
+        ORDER BY timestamp ASC
+      SQL
+
+      current_time = Time.current
+      binds = [[nil, current_time - 1.day], [nil, current_time]]
+      executions_data = GoodJob::Execution.connection.exec_query(count_query, "GoodJob Dashboard Chart", binds)
+
+      queue_names = executions_data.map { |d| d['queue_name'] }.uniq
+      labels = []
+      queues_data = executions_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
+        labels << timestamp.in_time_zone.strftime('%H:%M %z')
+        queue_names.each do |queue_name|
+          (hash[queue_name] ||= []) << values.find { |d| d['queue_name'] == queue_name }&.[]('count')
+        end
+      end
+
+      {
+        labels: labels,
+        series: queues_data.map do |queue, data|
+          {
+            name: queue,
+            data: data,
+          }
+        end,
+      }
+    end
+
+    private
+
+    def base_query
+      raise NotImplementedError
+    end
+
+    def filtered_query
+      raise NotImplementedError
+    end
+  end
+end

data/engine/app/filters/good_job/executions_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GoodJob
+  class ExecutionsFilter < BaseFilter
+    def states
+      {
+        'finished' => base_query.finished.count,
+        'unfinished' => base_query.unfinished.count,
+        'running' => base_query.running.count,
+        'errors' => base_query.where.not(error: nil).count,
+      }
+    end
+
+    private
+
+    def base_query
+      GoodJob::Execution.all
+    end
+
+    def filtered_query
+      query = base_query
+      query = query.job_class(params[:job_class]) if params[:job_class]
+      query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
+
+      if params[:state]
+        case params[:state]
+        when 'finished'
+          query = query.finished
+        when 'unfinished'
+          query = query.unfinished
+        when 'running'
+          query = query.running
+        when 'errors'
+          query = query.where.not(error: nil)
+        end
+      end
+
+      query
+    end
+  end
+end

data/engine/app/filters/good_job/jobs_filter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module GoodJob
+  class JobsFilter < BaseFilter
+    def states
+      {
+        'scheduled' =>  base_query.scheduled.count,
+        'retried' => base_query.retried.count,
+        'queued' => base_query.queued.count,
+        'running' => base_query.running.count,
+        'finished' => base_query.finished.count,
+        'discarded' => base_query.discarded.count,
+      }
+    end
+
+    private
+
+    def base_query
+      GoodJob::ActiveJobJob.all
+    end
+
+    def filtered_query
+      query = base_query
+      query = query.job_class(params[:job_class]) if params[:job_class]
+      query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
+
+      if params[:state]
+        case params[:state]
+        when 'discarded'
+          query = query.discarded
+        when 'finished'
+          query = query.finished
+        when 'retried'
+          query = query.retried
+        when 'scheduled'
+          query = query.scheduled
+        when 'running'
+          query = query.running.select('good_jobs.*', 'pg_locks.locktype')
+        when 'queued'
+          query = query.queued
+        end
+      end
+
+      query
+    end
+  end
+end

data/engine/app/helpers/good_job/application_helper.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 module GoodJob
   module ApplicationHelper
+    def relative_time(timestamp)
+      text = timestamp.future? ? "in #{time_ago_in_words(timestamp)}" : "#{time_ago_in_words(timestamp)} ago"
+      tag.time(text, datetime: timestamp, title: timestamp)
+    end
   end
 end

data/engine/app/models/good_job/active_job_job.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+module GoodJob
+  # ActiveRecord model that represents an +ActiveJob+ job.
+  # Is the same record data as a {GoodJob::Execution} but only the most recent execution.
+  # Parent class can be configured with +GoodJob.active_record_parent_class+.
+  # @!parse
+  #   class ActiveJob < ActiveRecord::Base; end
+  class ActiveJobJob < Object.const_get(GoodJob.active_record_parent_class)
+    include GoodJob::Lockable
+
+    self.table_name = 'good_jobs'
+    self.primary_key = 'active_job_id'
+    self.advisory_lockable_column = 'active_job_id'
+
+    has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id'
+
+    # Only the most-recent unretried execution represents a "Job"
+    default_scope { where(retried_good_job_id: nil) }
+
+    # Get Jobs with given class name
+    # @!method job_class
+    # @!scope class
+    # @param string [String]
+    #   Execution class name
+    # @return [ActiveRecord::Relation]
+    scope :job_class, ->(job_class) { where("serialized_params->>'job_class' = ?", job_class) }
+
+    # First execution will run in the future
+    scope :scheduled, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer < 2") }
+    # Execution errored, will run in the future
+    scope :retried, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer > 1") }
+    # Immediate/Scheduled time to run has passed, waiting for an available thread run
+    scope :queued, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) <= ?', DateTime.current).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+    # Advisory locked and executing
+    scope :running, -> { where(finished_at: nil).joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
+    # Completed executing successfully
+    scope :finished, -> { where.not(finished_at: nil).where(error: nil) }
+    # Errored but will not be retried
+    scope :discarded, -> { where.not(finished_at: nil).where.not(error: nil) }
+
+    # Get Jobs in display order with optional keyset pagination.
+    # @!method display_all(after_scheduled_at: nil, after_id: nil)
+    # @!scope class
+    # @param after_scheduled_at [DateTime, String, nil]
+    #   Display records scheduled after this time for keyset pagination
+    # @param after_id [Numeric, String, nil]
+    #   Display records after this ID for keyset pagination
+    # @return [ActiveRecord::Relation]
+    scope :display_all, (lambda do |after_scheduled_at: nil, after_id: nil|
+      query = order(Arel.sql('COALESCE(scheduled_at, created_at) DESC, id DESC'))
+      if after_scheduled_at.present? && after_id.present?
+        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at), id) < (:after_scheduled_at, :after_id)'), after_scheduled_at: after_scheduled_at, after_id: after_id)
+      elsif after_scheduled_at.present?
+        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at)) < (:after_scheduled_at)'), after_scheduled_at: after_scheduled_at)
+      end
+      query
+    end)
+
+    def id
+      active_job_id
+    end
+
+    def _execution_id
+      attributes['id']
+    end
+
+    def job_class
+      serialized_params['job_class']
+    end
+
+    def status
+      if finished_at.present?
+        if error.present?
+          :discarded
+        else
+          :finished
+        end
+      elsif (scheduled_at || created_at) > DateTime.current
+        if serialized_params.fetch('executions', 0) > 1
+          :retried
+        else
+          :scheduled
+        end
+      elsif running?
+        :running
+      else
+        :queued
+      end
+    end
+
+    def head_execution
+      executions.last
+    end
+
+    def tail_execution
+      executions.first
+    end
+
+    def executions_count
+      aj_count = serialized_params.fetch('executions', 0)
+      # The execution count within serialized_params is not updated
+      # once the underlying execution has been executed.
+      if status.in? [:discarded, :finished, :running]
+        aj_count + 1
+      else
+        aj_count
+      end
+    end
+
+    def preserved_executions_count
+      executions.size
+    end
+
+    def recent_error
+      error.presence || executions[-2]&.error
+    end
+
+    def running?
+      # Avoid N+1 Query: `.joins_advisory_locks.select('good_jobs.*', 'pg_locks.locktype AS locktype')`
+      if has_attribute?(:locktype)
+        self['locktype'].present?
+      else
+        advisory_locked?
+      end
+    end
+  end
+end

data/engine/app/views/good_job/cron_schedules/index.html.erb

@@ -0,0 +1,50 @@
+<% if @cron_schedules.present? %>
+  <div class="card my-3">
+    <div class="table-responsive">
+      <table class="table card-table table-bordered table-hover table-sm mb-0">
+        <thead>
+          <th>Cron Job Name</th>
+          <th>Configuration</th>
+          <th>
+            Set&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-properties" },
+                           aria: { expanded: false, controls: @cron_schedules.map { |job_key, _| "##{job_key.to_param}" }.join(" ") }
+            %>
+          </th>
+          <th>Class</th>
+          <th>Description</th>
+          <th>Next scheduled</th>
+        </thead>
+        <tbody>
+          <% @cron_schedules.each do |job_key, job| %>
+            <tr>
+              <td class="font-monospace"><%= job_key %></td>
+              <td class="font-monospace"><%= job[:cron] %></td>
+              <td>
+                <%=
+                  case job[:set]
+                  when NilClass
+                    "None"
+                  when Proc
+                    "Lambda/Callable"
+                  when Hash
+                    tag.button("Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                        data: { bs_toggle: "collapse", bs_target: "##{job_key.to_param}" },
+                        aria: { expanded: false, controls: job_key.to_param }) +
+                      tag.pre(JSON.pretty_generate(job[:set]), id: job_key.to_param, class: "collapse job-properties")
+                  end
+                %>
+              </td>
+              <td class="font-monospace"><%= job[:class] %></td>
+              <td><%= job[:description] %></td>
+              <td><%= Fugit.parse_cron(job[:cron]).next_time.to_local_time %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  </div>
+<% else %>
+  <em>No cron jobs present.</em>
+<% end %>

data/engine/app/views/good_job/executions/index.html.erb

@@ -0,0 +1,21 @@
+<div class="card my-3 p-6">
+  <%= render 'good_job/shared/chart', chart_data: @filter.chart_data %>
+</div>
+
+<%= render 'good_job/shared/filter', filter: @filter %>
+
+<% if @filter.records.present? %>
+  <%= render 'good_job/shared/executions_table', executions: @filter.records %>
+
+  <nav aria-label="Job pagination" class="mt-3">
+    <ul class="pagination">
+      <li class="page-item">
+        <%= link_to({ after_scheduled_at: (@filter.last.scheduled_at || @filter.last.created_at), after_id: @filter.last.id }, class: "page-link") do %>
+          Older executions <span aria-hidden="true">&raquo;</span>
+        <% end %>
+      </li>
+    </ul>
+  </nav>
+<% else %>
+  <em>No executions present.</em>
+<% end %>

data/engine/app/views/good_job/jobs/index.html.erb

@@ -0,0 +1,7 @@
+<div class="card my-3 p-6">
+  <%= render 'good_job/shared/chart', chart_data: @filter.chart_data %>
+</div>
+
+<%= render 'good_job/shared/filter', filter: @filter %>
+
+<%= render 'good_job/shared/jobs_table', jobs: @filter.records %>

data/engine/app/views/good_job/jobs/show.html.erb

@@ -0,0 +1,3 @@
+<h1>ActiveJob ID: <code><%= @executions.first.id %></code></h1>
+
+<%= render 'good_job/shared/executions_table', executions: @executions %>

data/engine/app/views/good_job/shared/_executions_table.erb

@@ -0,0 +1,56 @@
+<div class="card my-3">
+  <div class="table-responsive">
+    <table class="table card-table table-bordered table-hover table-sm mb-0">
+      <thead>
+        <tr>
+          <th>ActiveJob ID</th>
+          <th>Execution ID</th>
+          <th>Job Class</th>
+          <th>Queue</th>
+          <th>Scheduled At</th>
+          <th>Error</th>
+          <th>
+            ActiveJob Params&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-params" },
+                           aria: { expanded: false, controls: executions.map { |execution| "##{dom_id(execution, "params")}" }.join(" ") }
+            %>
+          </th>
+          <th>Actions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% executions.each do |execution| %>
+          <tr id="<%= dom_id(execution) %>">
+            <td>
+              <%= link_to job_path(execution.serialized_params['job_id']) do %>
+                <code><%= execution.active_job_id %></code>
+              <% end %>
+            </td>
+            <td>
+              <%= link_to job_path(execution.active_job_id, anchor: dom_id(execution)) do %>
+                <code><%= execution.id %></code>
+              <% end %>
+            </td>
+            <td><%= execution.serialized_params['job_class'] %></td>
+            <td><%= execution.queue_name %></td>
+            <td><%= relative_time(execution.scheduled_at || execution.created_at) %></td>
+            <td class="text-break"><%= truncate(execution.error, length: 1_000) %></td>
+            <td>
+              <%= tag.button "Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                data: { bs_toggle: "collapse", bs_target: "##{dom_id(execution, 'params')}" },
+                aria: { expanded: false, controls: dom_id(execution, "params") }
+              %>
+              <%= tag.pre JSON.pretty_generate(execution.serialized_params), id: dom_id(execution, "params"), class: "collapse job-params" %>
+            </td>
+            <td>
+              <%= button_to execution_path(execution.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete execution" do %>
+                <%= render "good_job/shared/icons/trash" %>
+              <% end %>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+</div>

data/engine/app/views/good_job/shared/_filter.erb

@@ -0,0 +1,52 @@
+<div class='card mb-2'>
+  <div class='card-body d-flex flex-wrap'>
+
+    <div class='me-4'>
+      <small>Filter by job class</small>
+      <br>
+      <% @filter.job_classes.each do |name, count| %>
+        <% if params[:job_class] == name %>
+          <%= link_to(@filter.to_params(job_class: nil), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% else %>
+          <%= link_to(@filter.to_params(job_class: name), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class='me-4'>
+      <small>Filter by state</small>
+      <br>
+      <% @filter.states.each do |name, count| %>
+        <% if params[:state] == name %>
+          <%= link_to(@filter.to_params(state: nil), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% else %>
+          <%= link_to(@filter.to_params(state: name), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div>
+      <small>Filter by queue</small>
+      <br>
+      <% @filter.queues.each do |name, count| %>
+        <% if params[:queue_name] == name %>
+          <%= link_to(@filter.to_params(queue_name: nil), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% else %>
+          <%= link_to(@filter.to_params(queue_name: name), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% end %>
+      <% end %>
+    </div>
+  </div>
+</div>

data/engine/app/views/good_job/shared/_jobs_table.erb

@@ -3,11 +3,12 @@
     <table class="table card-table table-bordered table-hover table-sm mb-0">
       <thead>
         <tr>
-          <th>GoodJob ID</th>
           <th>ActiveJob ID</th>
+          <th>State</th>
           <th>Job Class</th>
           <th>Queue</th>
           <th>Scheduled At</th>
+          <th>Executions</th>
           <th>Error</th>
           <th>
             ActiveJob Params&nbsp;
@@ -22,12 +23,19 @@
       <tbody>
         <% jobs.each do |job| %>
           <tr id="<%= dom_id(job) %>">
-            <td><%= link_to job.id, active_job_path(job.serialized_params['job_id'], anchor: dom_id(job)) %></td>
-            <td><%= link_to job.serialized_params['job_id'], active_job_path(job.serialized_params['job_id']) %></td>
-            <td><%= job.serialized_params['job_class'] %></td>
+            <td>
+              <%= link_to job_path(job.id) do %>
+                <code><%= job.id %></code>
+              <% end %>
+            </td>
+            <td>
+              <span class="badge bg-secondary"><%= job.status %></span>
+            </td>
+            <td><%= job.job_class %></td>
             <td><%= job.queue_name %></td>
-            <td><%= job.scheduled_at || job.created_at %></td>
-            <td class="text-break"><%= truncate(job.error, length: 1_000) %></td>
+            <td><%= relative_time(job.scheduled_at || job.created_at) %></td>
+            <td><%= job.executions_count %></td>
+            <td class="text-break"><%= truncate(job.recent_error, length: 1_000) %></td>
             <td>
               <%= tag.button "Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
                 data: { bs_toggle: "collapse", bs_target: "##{dom_id(job, 'params')}" },
@@ -35,11 +43,11 @@
               %>
               <%= tag.pre JSON.pretty_generate(job.serialized_params), id: dom_id(job, "params"), class: "collapse job-params" %>
             </td>
-            <td>
-              <%= button_to job_path(job.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete job" do %>
-                <%= render "good_job/shared/icons/trash" %>
-              <% end %>
-            </td>
+<!--            <td>-->
+              <%#= button_to execution_path(execution.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete execution" do %>
+                <%#= render "good_job/shared/icons/trash" %>
+              <%# end %>
+<!--            </td>-->
           </tr>
         <% end %>
       </tbody>

data/engine/app/views/layouts/good_job/base.html.erb

@@ -23,9 +23,18 @@
       <div class="collapse navbar-collapse" id="navbarSupportedContent">
         <ul class="navbar-nav me-auto">
           <li class="nav-item">
-            <%= link_to root_path, class: ["nav-link", ("active" if current_page?(root_path))] do %>
-              All jobs <span class="badge bg-secondary">More views coming soon</span>
-            <% end %>
+            <%= link_to "All Executions", root_path, class: ["nav-link", ("active" if current_page?(root_path))] %>
+          </li>
+          <li class="nav-item">
+            <%= link_to "All Jobs", jobs_path, class: ["nav-link", ("active" if current_page?(jobs_path))] %>
+          </li>
+          <li class="nav-item">
+            <%= link_to "Cron Schedules", cron_schedules_path, class: ["nav-link", ("active" if current_page?(cron_schedules_path))] %>
+          </li>
+          <li class="nav-item">
+            <div class="nav-link">
+              <span class="badge bg-secondary">More views coming soon</span>
+            </div>
           </li>
 
           <!-- Coming Soon
@@ -59,7 +68,7 @@
       </div>
     <% elsif alert %>
       <div class="alert alert-warning alert-dismissible fade show d-flex align-items-center offset-md-3 col-6" role="alert">
-        <%= render "good_job/shared/icons/check", class: "flex-shrink-0 me-2" %>
+        <%= render "good_job/shared/icons/exclamation", class: "flex-shrink-0 me-2" %>
         <div><%= alert %></div>
         <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
       </div>

data/engine/config/routes.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 GoodJob::Engine.routes.draw do
-  root to: 'dashboards#index'
-  resources :active_jobs, only: %i[show]
-  resources :jobs, only: %i[destroy]
+  root to: 'executions#index'
+  resources :cron_schedules, only: %i[index]
+  resources :jobs, only: %i[index show]
+  resources :executions, only: %i[destroy]
 
   scope controller: :assets do
     constraints(format: :css) do