onni 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 771c4d19c150aa9e930bc871dfa35b37f3f6b86098015225bc6ca602dac81762
-  data.tar.gz: eaad1fa8803d9eefaf51be764fe2d132629f1d02650bedc1b0874045e278fcd0
+  metadata.gz: fe9cc871e203addc591fead045947fd0049cff52deb2b24929fcf1d36f1f67c6
+  data.tar.gz: 3627534cc1ce27a21f64dd8f683930105949d9a354e880cc37d57de1d0f271ee
 SHA512:
-  metadata.gz: c1595142b9455666d5ba1249021f0a01434563d9e2a5f4a444cd7b671bc7bd8e971d281ce498e8889ac3682969372df9a35d116636ff5403438140c027811c2f
-  data.tar.gz: f06671e2e7f3ccb5bbc7381b9a4d4b022b7f2cbd3e68ff11c0a5d063883c7697ef4d3cd0fd65fdcd2461533c6aafd6965aa900d976eda17c2d1b24c3dc754927
+  metadata.gz: dfa4d5919712c0338b2fbbe313f0fa5163a737911cbfb672a16c069eb062c1f865a0c0efc29cc8227e7f0cf9d66e44e28f4c62a95a1fa47fb6647520a698164a
+  data.tar.gz: dafe6359be806579e86871b93553ad336609f88309aac7ac2d6cebbc5cbaf075b2ea94c5d044583804242bbca17de860372ed34cbcc263629c52705fd1aeab38

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 0.1.3 (2026-11-12)
+
+- ActiveAdmin Features index is Flags: search, expiry filters, pagination, All/Enabled/Disabled scope tabs with counts
+- Flags filters sit in the ActiveAdmin sidebar (`filters-form`)
+- Stats storage is a separate page (`/admin/features/stats`)
+- Optional `/admin/features/:key` show path via `Onni::ActiveAdminRoutes.draw`
+- Feature show uses ActiveAdmin layout wrappers and paginated table chrome
+- Colored Enable (orange) and Disable (red) actions on the Flags index
+
 ## 0.1.2 (2026-11-12)
 
 - ActiveAdmin Features index: one Enable or Disable action per flag, relative expiry with full date hint, compact hit metrics, no explainer panels

data/README.md

@@ -57,6 +57,18 @@ ActiveAdmin dashboard loads automatically when ActiveAdmin is present. You can a
 require "onni/active_admin"
 ```
 
+After `ActiveAdmin.routes(self)`, draw the feature show path (`/admin/features/:key`):
+
+```ruby
+ActiveAdmin.routes(self)
+Onni::ActiveAdminRoutes.draw(self)
+```
+
+`/admin/features` is the Flags index (search, filters, pagination, All/Enabled/Disabled scopes).
+Stats storage is at `/admin/features/stats`. The older `/admin/features/feature?key=` page action remains available.
+
+Host apps that authorize ActiveAdmin page actions by name need a `stats?` rule for the Features page (alongside `enable?`, `disable?`, `feature?`, and `update_feature?` when those are checked).
+
 ## YAML registry
 
 Every flag must be listed in `config/features.yml`:

data/app/admin/features.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "onni/admin/flags_query"
+
 ActiveAdmin.register_page "Features" do
   menu priority: 3, label: proc { I18n.t("onni.menu", default: "Features") },
     if: proc { instance_exec(&Onni.configuration.admin_authorized) }
@@ -7,6 +9,8 @@ ActiveAdmin.register_page "Features" do
   controller do
     before_action :onni_require_admin!
 
+    helper_method :onni_feature_path
+
     private
 
     def onni_require_admin!
@@ -14,61 +18,159 @@ ActiveAdmin.register_page "Features" do
 
       head :forbidden
     end
+
+    def onni_feature_path(key, **options)
+      Onni::ActiveAdminRoutes.feature_path_helper(view_context, key, **options)
+    end
   end
 
-  content title: "Features" do
-    flags = Onni::Registry.config.keys.sort.map { |key| Onni::Flag.new(key) }
-    overview = Onni.stats_overview
-    retention = overview[:retention]
-
-    h3 "Hit storage"
-    table class: "onni-hit-storage mb-4" do
-      tr do
-        th "Buckets"
-        th "Oldest hour"
-        th "Retention"
-        th "Sample rate"
-        th "Alerts"
-      end
-      tr do
-        td overview[:bucket_count]
-        td(overview[:oldest_period_start] || "—")
-        td(retention ? "#{(retention / 1.day).to_i} days" : "not set")
-        td overview[:sample_rate]
-        td do
-          status_tag("Past retention") if overview[:past_retention]
-          status_tag("Large table") if overview[:large_table]
-          text_node "—" unless overview[:past_retention] || overview[:large_table]
+  action_item :stats_storage, only: :index do
+    link_to "Stats storage", admin_features_stats_path, class: "action-item-button"
+  end
+
+  sidebar "Filters", only: :index do
+    query = Onni::Admin::FlagsQuery.new(params)
+
+    h3 I18n.t("active_admin.sidebars.filters", default: "Filters"), class: "filters-form-title"
+
+    text_node helpers.form_tag(helpers.admin_features_path, method: :get, class: "filters-form") {
+      helpers.safe_join([
+        (helpers.hidden_field_tag(:scope, query.scope) unless query.scope == Onni::Admin::FlagsQuery::DEFAULT_SCOPE),
+        helpers.tag.div(class: "filters-form-field") {
+          helpers.safe_join([
+            helpers.label_tag(:q, "Search"),
+            helpers.text_field_tag(:q, query.search, id: "q")
+          ])
+        },
+        helpers.tag.div(class: "filters-form-field") {
+          helpers.safe_join([
+            helpers.label_tag(:expires, "Expires"),
+            helpers.select_tag(
+              :expires,
+              helpers.options_for_select(
+                [
+                  ["Any", ""],
+                  ["With expiry", "with"],
+                  ["Without expiry", "without"],
+                  ["Past expiry", "past"]
+                ],
+                query.expires_filter
+              ),
+              id: "expires"
+            )
+          ])
+        },
+        helpers.tag.div(class: "filters-form-field") {
+          helpers.safe_join([
+            helpers.label_tag(:per, "Per page"),
+            helpers.select_tag(
+              :per,
+              helpers.options_for_select(
+                Onni::Admin::FlagsQuery::PER_PAGE_OPTIONS,
+                query.per_page
+              ),
+              id: "per"
+            )
+          ])
+        },
+        helpers.tag.div(class: "filters-form-buttons") {
+          helpers.safe_join([
+            helpers.submit_tag(
+              I18n.t("active_admin.filters.buttons.filter", default: "Filter"),
+              class: "filters-form-submit"
+            ),
+            helpers.link_to(
+              I18n.t("active_admin.filters.buttons.clear", default: "Clear Filters"),
+              helpers.admin_features_path,
+              class: "filters-form-clear"
+            )
+          ])
+        }
+      ].compact)
+    }
+  end
+
+  content title: "Flags" do
+    query = Onni::Admin::FlagsQuery.new(params)
+    collection = query.page
+    tab_params = query.filter_params.except(:scope)
+    counts = query.scope_counts
+
+    div class: "scopes mb-4", role: "toolbar" do
+      div class: "index-button-group", role: "group" do
+        Onni::Admin::FlagsQuery::SCOPES.each do |scope_id|
+          label = (scope_id == "all") ? "All" : scope_id.capitalize
+          classes = ["index-button"]
+          classes << "index-button-selected" if query.scope == scope_id
+          a href: helpers.admin_features_path(tab_params.merge(scope: (scope_id == "all") ? nil : scope_id).compact),
+            class: classes.join(" ") do
+            text_node label
+            span counts.fetch(scope_id), class: "scopes-count"
+          end
         end
       end
     end
 
-    table_for flags do
-      column("Key") { |flag| link_to flag.name, admin_features_feature_path(key: flag.name) }
-      column("Description", &:description)
-      column("Expires") do |flag|
-        summary = flag.expires_summary
-        if summary
-          span summary, title: flag.expires_full, "data-onni-expires": true
-        else
-          span "—"
+    if collection.respond_to?(:total_pages)
+      paginated_collection(
+        collection,
+        entry_name: "flag",
+        download_links: false,
+        param_name: :page,
+        params: query.filter_params
+      ) do
+        div class: "index-as-table" do
+          table_for collection do
+            column("Key") { |flag| link_to flag.name, helpers.onni_feature_path(flag.name) }
+            column("Description", &:description)
+            column("Expires") do |flag|
+              summary = flag.expires_summary
+              if summary
+                span summary, title: flag.expires_full, "data-onni-expires": true
+              else
+                span "—"
+              end
+            end
+            column("Enabled globally") { |flag| status_tag(flag.enabled?(record_stats: false) ? "Yes" : "No") }
+            column("Gates") do |flag|
+              names = flag.gates.map { |gate| gate["key"] }
+              names.presence&.join(", ") || "—"
+            end
+            column("Actions") do |flag|
+              if flag.enabled?(record_stats: false)
+                button_to "Disable", admin_features_disable_path(key: flag.name),
+                  method: :post,
+                  class: "bg-red-500 hover:bg-red-700 text-white hover:text-white action-item-button"
+              else
+                button_to "Enable", admin_features_enable_path(key: flag.name),
+                  method: :post,
+                  class: "bg-orange-500 hover:bg-orange-700 text-white hover:text-white action-item-button"
+              end
+            end
+          end
         end
       end
-      column("Enabled globally") { |flag| status_tag(flag.enabled?(record_stats: false)) }
-      column("Gates") do |flag|
-        names = flag.gates.map { |gate| gate["key"] }
-        names.presence&.join(", ") || "—"
-      end
-      column("Actions") do |flag|
-        if flag.enabled?(record_stats: false)
-          button_to "Disable", admin_features_disable_path(key: flag.name), method: :post
-        else
-          button_to "Enable", admin_features_enable_path(key: flag.name), method: :post
+    else
+      div class: "paginated-collection" do
+        div class: "paginated-collection-contents" do
+          div class: "index-as-table" do
+            table_for collection do
+              column("Key") { |flag| link_to flag.name, helpers.onni_feature_path(flag.name) }
+              column("Description", &:description)
+              column("Enabled globally") { |flag| status_tag(flag.enabled?(record_stats: false) ? "Yes" : "No") }
+            end
+          end
         end
       end
     end
   end
 
+  page_action :stats, method: :get do
+    @overview = Onni.stats_overview
+    @page_title = "Stats storage"
+    render "admin/features/stats", layout: "active_admin"
+  end
+
   page_action :enable, method: :post do
     Onni.enable(params.require(:key))
     redirect_to admin_features_path, notice: "Enabled #{params[:key]}"
@@ -85,23 +187,36 @@ ActiveAdmin.register_page "Features" do
 
     @flag = Onni::Flag.new(params.require(:key))
     @hit_chart = Onni::HitChart.new(@flag.name, range: range)
+    @page_title = @flag.name
     render "admin/features/show", layout: "active_admin"
   end
 
   page_action :update_feature, method: :post do
     key = params.require(:key)
-    percentage = params[:percentage].presence
+    feature_params = params[:feature].presence || params
+    percentage = feature_params[:percentage].presence
     Onni.enable_percentage_of_actors(key, percentage.to_i) if percentage
-    if params[:variants].present?
-      variants = params[:variants].to_unsafe_h.transform_values(&:to_i).reject { |_name, weight| weight <= 0 }
+    if feature_params[:control].present? || feature_params[:treatment].present? || params[:variants].present?
+      variants =
+        if params[:variants].present?
+          params[:variants].to_unsafe_h.transform_values(&:to_i)
+        else
+          {
+            "control" => feature_params[:control].to_i,
+            "treatment" => feature_params[:treatment].to_i
+          }
+        end
+      variants = variants.reject { |_name, weight| weight.to_i <= 0 }
       Onni.set_variants(key, variants) if variants.any?
     end
-    case params[:group_action]
+    group_action = feature_params[:group_action]
+    group_name = feature_params[:group_name]
+    case group_action
     when "enable"
-      Onni.enable_group(key, params.require(:group_name))
+      Onni.enable_group(key, group_name) if group_name.present?
     when "disable"
-      Onni.disable_group(key, params.require(:group_name))
+      Onni.disable_group(key, group_name) if group_name.present?
     end
-    redirect_to admin_features_feature_path(key: key), notice: "Updated #{key}"
+    redirect_to onni_feature_path(key), notice: "Updated #{key}"
   end
 end

data/app/models/onni/history_form.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Onni
+  class HistoryForm
+    include ActiveModel::Model
+
+    attr_accessor :range
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "History")
+    end
+  end
+end

data/app/models/onni/rollout_form.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Onni
+  class RolloutForm
+    include ActiveModel::Model
+
+    attr_accessor :percentage, :group_name, :group_action, :control, :treatment
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "Feature")
+    end
+  end
+end

data/app/views/admin/features/_stats.html.arb

@@ -0,0 +1,71 @@
+feature_path ||= helpers.onni_feature_path(flag.name)
+range_form = Onni::HistoryForm.new(range: chart.range)
+
+div do
+  h2 "Hits", class: "text-lg font-bold text-gray-700 dark:text-gray-200 mb-4", id: "onni-hit-history"
+
+  active_admin_form_for(
+    range_form,
+    url: feature_path,
+    method: :get
+  ) do |f|
+    f.inputs do
+      f.input :range,
+        as: :select,
+        label: "History",
+        collection: [["Last 24 hours", "24h"], ["Last 7 days", "7d"], ["Last 30 days", "30d"]],
+        include_blank: false,
+        input_html: {name: "range", id: "range"}
+    end
+    f.actions do
+      f.action :submit, label: "Show"
+    end
+  end
+
+  totals = [
+    {
+      "enabled" => helpers.number_with_delimiter(chart.enabled_hits),
+      "disabled" => helpers.number_with_delimiter(chart.disabled_hits),
+      "share" => chart.enabled_percentage ? helpers.number_to_percentage(chart.enabled_percentage, precision: 1) : "No data"
+    }
+  ]
+  div class: "paginated-collection mb-4" do
+    div class: "paginated-collection-contents" do
+      div class: "index-as-table" do
+        table_for totals do
+          column("Enabled") { |row| span row.fetch("enabled"), "data-onni-enabled-hits": true }
+          column("Disabled") { |row| span row.fetch("disabled"), "data-onni-disabled-hits": true }
+          column("Enabled share") { |row| span row.fetch("share"), "data-onni-enabled-percentage": true }
+        end
+      end
+    end
+  end
+
+  if chart.enabled_percentage.nil?
+    para role: "status", class: "my-4" do
+      text_node "No recorded evaluations in this window."
+    end
+  else
+    text_node helpers.render(partial: "admin/features/chart", locals: {chart: chart})
+  end
+
+  details class: "mt-4" do
+    summary "Counts by #{chart.hourly? ? "hour" : "day"} (UTC)"
+    div class: "paginated-collection mt-4" do
+      div class: "paginated-collection-contents" do
+        div class: "index-as-table" do
+          table_for chart.rows do
+            column(chart.hourly? ? "Hour" : "Day") do |row|
+              helpers.l(
+                chart.hourly? ? row.fetch("period_start") : row.fetch("period_start").to_date,
+                format: :short
+              )
+            end
+            column("Enabled") { |row| helpers.number_with_delimiter(row.fetch("enabled_hits")) }
+            column("Disabled") { |row| helpers.number_with_delimiter(row.fetch("disabled_hits")) }
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/admin/features/show.html.arb

@@ -0,0 +1,110 @@
+flag = assigns.fetch(:flag)
+chart = assigns.fetch(:hit_chart)
+variants = flag.variants
+enabled = flag.enabled?(record_stats: false)
+feature_path = helpers.onni_feature_path(flag.name)
+percentage = flag.gates.find { |gate| gate["key"] == "percentage_of_actors" }&.fetch("value", nil)
+rollout_form = Onni::RolloutForm.new(
+  percentage: percentage,
+  group_name: nil,
+  group_action: nil,
+  control: variants["control"],
+  treatment: variants["treatment"]
+)
+
+div class: "main-content-container" do
+  div class: "space-y-10" do
+    if flag.description.present?
+      para do
+        text_node flag.description
+      end
+    end
+
+    div do
+      h2 "Overview", class: "text-lg font-bold text-gray-700 dark:text-gray-200 mb-4"
+      attributes_table_for(flag) do
+        row("Status") { status_tag(enabled ? "Enabled" : "Disabled") }
+        row("Expires") do
+          if flag.expires_summary
+            span flag.expires_summary, title: flag.expires_full, "data-onni-expires": true
+          else
+            span "—"
+          end
+        end
+        row("Sample rate") do
+          if !Onni.configuration.stats_enabled
+            text_node "off"
+          elsif Array(Onni.configuration.stats_ignore).any? { |key| key.to_s == flag.name }
+            text_node "ignored"
+          else
+            text_node Onni.configuration.stats_sample_rate
+          end
+        end
+      end
+    end
+
+    div do
+      h2 "Gates", class: "text-lg font-bold text-gray-700 dark:text-gray-200 mb-4"
+      if flag.gates.empty?
+        para { text_node "None" }
+      else
+        div class: "paginated-collection" do
+          div class: "paginated-collection-contents" do
+            div class: "index-as-table" do
+              table_for flag.gates do
+                column("Key") { |gate| code gate["key"] }
+                column("Value") { |gate| code gate["value"] }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    div do
+      h2 "Rollout", class: "text-lg font-bold text-gray-700 dark:text-gray-200 mb-4"
+      active_admin_form_for(
+        rollout_form,
+        url: helpers.admin_features_update_feature_path(key: flag.name),
+        method: :post
+      ) do |f|
+        f.inputs do
+          f.input :percentage,
+            as: :number,
+            label: "Percentage of actors (0-100)",
+            input_html: {min: 0, max: 100, name: "percentage", id: "percentage"}
+          f.input :group_name,
+            as: :select,
+            collection: Onni::Group.names,
+            include_blank: true,
+            input_html: {name: "group_name", id: "group_name"}
+          f.input :group_action,
+            as: :select,
+            collection: [%w[Enable enable], %w[Disable disable]],
+            include_blank: "Action",
+            input_html: {name: "group_action", id: "group_action"}
+          f.input :control,
+            as: :number,
+            label: "Variant control",
+            input_html: {min: 0, max: 100, name: "variants[control]", id: "variant_control"}
+          f.input :treatment,
+            as: :number,
+            label: "Variant treatment",
+            input_html: {min: 0, max: 100, name: "variants[treatment]", id: "variant_treatment"}
+        end
+        f.actions do
+          f.action :submit, label: "Save"
+        end
+      end
+    end
+
+    text_node helpers.render(
+      partial: "admin/features/stats",
+      locals: {chart: chart, flag: flag, feature_path: feature_path}
+    )
+
+    para do
+      text_node helpers.link_to("Back to features", helpers.admin_features_path, class: "action-item-button")
+    end
+  end
+end

data/app/views/admin/features/stats.html.arb

@@ -0,0 +1,49 @@
+overview = assigns.fetch(:overview)
+retention = overview[:retention]
+record = Onni::Flag.new("stats_storage")
+
+div class: "main-content-container" do
+  div class: "space-y-10" do
+    para class: "text-gray-700 dark:text-gray-200" do
+      text_node "Storage used for feature evaluation hit stats. Retention and sampling come from Onni configuration."
+    end
+
+    div do
+      h2 "Overview", class: "text-lg font-bold text-gray-700 dark:text-gray-200 mb-4"
+      attributes_table_for(record) do
+        row("Buckets") { overview[:bucket_count] }
+        row("Oldest hour") { overview[:oldest_period_start] || "—" }
+        row("Retention") { retention ? "#{(retention / 1.day).to_i} days" : "not set" }
+        row("Sample rate") { overview[:sample_rate] }
+        row("Scale sampled hits") { overview[:scale_sampled_hits] ? "yes" : "no" }
+        row("Past retention") { status_tag(overview[:past_retention] ? "Yes" : "No") }
+        row("Large table") { status_tag(overview[:large_table] ? "Yes" : "No") }
+      end
+    end
+
+    div do
+      h2 "Alerts", class: "text-lg font-bold text-gray-700 dark:text-gray-200 mb-4"
+      if overview[:past_retention] || overview[:large_table]
+        div class: "paginated-collection" do
+          div class: "paginated-collection-contents" do
+            div class: "index-as-table" do
+              table_for [
+                ({"alert" => "Past retention", "detail" => "Oldest bucket is older than configured retention"} if overview[:past_retention]),
+                ({"alert" => "Large table", "detail" => "Bucket count is at or above #{Onni::Stats::Overview::ROW_WARNING}"} if overview[:large_table])
+              ].compact do
+                column("Alert") { |row| row.fetch("alert") }
+                column("Detail") { |row| row.fetch("detail") }
+              end
+            end
+          end
+        end
+      else
+        para { text_node "No storage alerts." }
+      end
+    end
+
+    para do
+      text_node helpers.link_to("Back to flags", helpers.admin_features_path, class: "action-item-button")
+    end
+  end
+end

data/lib/onni/active_admin.rb

@@ -7,6 +7,7 @@
 #   require "onni/active_admin"
 #
 require "onni"
+require "onni/active_admin_routes"
 
 raise LoadError, "ActiveAdmin is required for onni/active_admin" unless defined?(ActiveAdmin)
 

data/lib/onni/active_admin_routes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Onni
+  # Draw after `ActiveAdmin.routes(self)` so `/admin/features/:key` reaches the
+  # Features page show action. Reserved page_action names stay on their AA paths.
+  module ActiveAdminRoutes
+    RESERVED_KEYS = %w[enable disable feature update_feature stats].freeze
+    KEY_PATTERN = /[A-Za-z0-9_.:-]+/
+
+    module_function
+
+    def draw(router)
+      router.instance_eval do
+        get "/admin/features/:key",
+          to: "admin/features#feature",
+          as: :admin_feature,
+          constraints: ->(req) {
+            key = req.path_parameters[:key].to_s
+            Onni::ActiveAdminRoutes::KEY_PATTERN.match?(key) &&
+              !Onni::ActiveAdminRoutes::RESERVED_KEYS.include?(key)
+          }
+      end
+    end
+
+    def feature_path_helper(view, key, **options)
+      if view.respond_to?(:admin_feature_path)
+        view.admin_feature_path(key, **options)
+      else
+        view.admin_features_feature_path(**options.merge(key: key))
+      end
+    end
+  end
+end

data/lib/onni/admin/flags_query.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Onni
+  module Admin
+    # Filters and pages registry flags for the ActiveAdmin Features index.
+    class FlagsQuery
+      DEFAULT_PER_PAGE = 25
+      PER_PAGE_OPTIONS = [10, 25, 50, 100].freeze
+      SCOPES = %w[all enabled disabled].freeze
+      DEFAULT_SCOPE = "all"
+
+      def initialize(params = {})
+        source = params.presence || {}
+        @params = {
+          q: source[:q],
+          scope: source[:scope],
+          expires: source[:expires],
+          per: source[:per],
+          page: source[:page]
+        }.with_indifferent_access
+      end
+
+      def flags
+        @flags ||= filter_scope(pre_scope_flags)
+      end
+
+      def page
+        @page ||= begin
+          scope = flags
+          if defined?(Kaminari)
+            Kaminari.paginate_array(scope).page(@params[:page]).per(per_page)
+          else
+            scope
+          end
+        end
+      end
+
+      def search
+        @params[:q].to_s.strip
+      end
+
+      def scope
+        value = @params[:scope].to_s
+        SCOPES.include?(value) ? value : DEFAULT_SCOPE
+      end
+
+      def expires_filter
+        @params[:expires].to_s
+      end
+
+      def per_page
+        value = @params[:per].to_i
+        PER_PAGE_OPTIONS.include?(value) ? value : DEFAULT_PER_PAGE
+      end
+
+      def filter_params
+        {
+          q: search.presence,
+          scope: (scope == DEFAULT_SCOPE) ? nil : scope,
+          expires: expires_filter.presence,
+          per: per_page
+        }.compact
+      end
+
+      def scope_counts
+        base = pre_scope_flags
+        enabled = base.count { |flag| flag.enabled?(record_stats: false) }
+        {
+          "all" => base.size,
+          "enabled" => enabled,
+          "disabled" => base.size - enabled
+        }
+      end
+
+      private
+
+      def all_flags
+        @all_flags ||= Onni::Registry.config.keys.sort.map { |key| Onni::Flag.new(key) }
+      end
+
+      def pre_scope_flags
+        @pre_scope_flags ||= filter_expires(filter_search(all_flags))
+      end
+
+      def filter_search(list)
+        query = search.downcase
+        return list if query.blank?
+
+        list.select do |flag|
+          flag.name.downcase.include?(query) || flag.description.to_s.downcase.include?(query)
+        end
+      end
+
+      def filter_scope(list)
+        case scope
+        when "enabled"
+          list.select { |flag| flag.enabled?(record_stats: false) }
+        when "disabled"
+          list.reject { |flag| flag.enabled?(record_stats: false) }
+        else
+          list
+        end
+      end
+
+      def filter_expires(list)
+        case expires_filter
+        when "with"
+          list.select { |flag| flag.expires_on }
+        when "without"
+          list.reject { |flag| flag.expires_on }
+        when "past"
+          today = Time.now.utc.to_date
+          list.select { |flag| flag.expires_on && flag.expires_on < today }
+        else
+          list
+        end
+      end
+    end
+  end
+end

data/lib/onni/engine.rb

@@ -2,6 +2,9 @@
 
 return unless defined?(Rails::Engine)
 
+require "onni/active_admin_routes"
+require "onni/admin/flags_query"
+
 module Onni
   class Engine < ::Rails::Engine
     engine_name "onni"
@@ -23,6 +26,8 @@ module Onni
     initializer "onni.load_active_admin" do
       next unless defined?(ActiveAdmin)
 
+      require "onni/active_admin_routes"
+
       path = root.join("app/admin").to_s
       ActiveSupport.on_load(:after_initialize) do
         ActiveAdmin.application.load_paths << path unless ActiveAdmin.application.load_paths.include?(path)

data/lib/onni/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Onni
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onni
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrei Makarov
@@ -303,11 +303,14 @@ files:
 - app/admin/features.rb
 - app/models/onni/feature.rb
 - app/models/onni/gate.rb
+- app/models/onni/history_form.rb
 - app/models/onni/hit_chart.rb
+- app/models/onni/rollout_form.rb
 - app/models/onni/stat_bucket.rb
 - app/views/admin/features/_chart.html.erb
-- app/views/admin/features/_stats.html.erb
-- app/views/admin/features/show.html.erb
+- app/views/admin/features/_stats.html.arb
+- app/views/admin/features/show.html.arb
+- app/views/admin/features/stats.html.arb
 - config/locales/en.yml
 - config/polyrun_coverage.yml
 - lib/generators/onni/install_generator.rb
@@ -319,9 +322,11 @@ files:
 - lib/generators/onni/templates/purge_stats_job.rb.tt
 - lib/onni.rb
 - lib/onni/active_admin.rb
+- lib/onni/active_admin_routes.rb
 - lib/onni/actor.rb
 - lib/onni/adapters/active_record.rb
 - lib/onni/adapters/memory.rb
+- lib/onni/admin/flags_query.rb
 - lib/onni/conditions.rb
 - lib/onni/configuration.rb
 - lib/onni/engine.rb

data/app/views/admin/features/_stats.html.erb

@@ -1,54 +0,0 @@
-<section aria-labelledby="onni-hit-history" class="mb-6">
-  <h3 id="onni-hit-history" class="font-semibold mb-2">Hits</h3>
-  <%= form_with url: admin_features_feature_path, method: :get, local: true, class: "mb-4" do %>
-    <%= hidden_field_tag :key, flag.name %>
-    <%= label_tag :range, "History" %>
-    <%= select_tag :range, options_for_select([["Last 24 hours", "24h"], ["Last 7 days", "7d"], ["Last 30 days", "30d"]], chart.range) %>
-    <%= submit_tag "Show", name: nil, class: "button" %>
-  <% end %>
-
-  <table class="mb-4 onni-hit-totals">
-    <thead>
-      <tr>
-        <th scope="col">Enabled</th>
-        <th scope="col">Disabled</th>
-        <th scope="col">Enabled share</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td data-onni-enabled-hits><%= number_with_delimiter(chart.enabled_hits) %></td>
-        <td data-onni-disabled-hits><%= number_with_delimiter(chart.disabled_hits) %></td>
-        <td data-onni-enabled-percentage><%= chart.enabled_percentage ? number_to_percentage(chart.enabled_percentage, precision: 1) : "No data" %></td>
-      </tr>
-    </tbody>
-  </table>
-
-  <% if chart.enabled_percentage.nil? %>
-    <p role="status" class="my-4">No recorded evaluations in this window.</p>
-  <% else %>
-    <%= render partial: "admin/features/chart", locals: { chart: chart } %>
-  <% end %>
-
-  <details class="mt-4">
-    <summary>Counts by <%= chart.hourly? ? "hour" : "day" %> (UTC)</summary>
-    <table>
-      <thead>
-        <tr>
-          <th scope="col"><%= chart.hourly? ? "Hour" : "Day" %></th>
-          <th scope="col">Enabled</th>
-          <th scope="col">Disabled</th>
-        </tr>
-      </thead>
-      <tbody>
-        <% chart.rows.each do |row| %>
-          <tr>
-            <th scope="row"><%= l(chart.hourly? ? row.fetch("period_start") : row.fetch("period_start").to_date, format: :short) %></th>
-            <td><%= number_with_delimiter(row.fetch("enabled_hits")) %></td>
-            <td><%= number_with_delimiter(row.fetch("disabled_hits")) %></td>
-          </tr>
-        <% end %>
-      </tbody>
-    </table>
-  </details>
-</section>

data/app/views/admin/features/show.html.erb

@@ -1,88 +0,0 @@
-<% flag = @flag %>
-<% variants = flag.variants %>
-<% enabled = flag.enabled?(record_stats: false) %>
-<div>
-  <h2 class="text-xl font-semibold mb-2"><%= flag.name %></h2>
-  <% if flag.description.present? %>
-    <p class="mb-3"><%= flag.description %></p>
-  <% end %>
-
-  <table class="mb-4">
-    <tbody>
-      <tr>
-        <th scope="row">Status</th>
-        <td><%= enabled ? "Enabled" : "Disabled" %></td>
-        <th scope="row">Expires</th>
-        <td>
-          <% if flag.expires_summary %>
-            <span title="<%= flag.expires_full %>" data-onni-expires><%= flag.expires_summary %></span>
-          <% else %>
-            —
-          <% end %>
-        </td>
-        <th scope="row">Sample rate</th>
-        <td>
-          <% if !Onni.configuration.stats_enabled %>
-            off
-          <% elsif Array(Onni.configuration.stats_ignore).any? { |key| key.to_s == flag.name } %>
-            ignored
-          <% else %>
-            <%= Onni.configuration.stats_sample_rate %>
-          <% end %>
-        </td>
-      </tr>
-    </tbody>
-  </table>
-
-  <h3 class="font-semibold mb-2">Gates</h3>
-  <% if flag.gates.empty? %>
-    <p class="mb-4">None</p>
-  <% else %>
-    <table class="mb-4">
-      <thead>
-        <tr>
-          <th scope="col">Key</th>
-          <th scope="col">Value</th>
-        </tr>
-      </thead>
-      <tbody>
-        <% flag.gates.each do |gate| %>
-          <tr>
-            <td><code><%= gate["key"] %></code></td>
-            <td><code><%= gate["value"] %></code></td>
-          </tr>
-        <% end %>
-      </tbody>
-    </table>
-  <% end %>
-
-  <%= form_with url: admin_features_update_feature_path(key: flag.name), method: :post, local: true, class: "mb-6 space-y-3" do %>
-    <div>
-      <label>Percentage of actors (0-100)</label>
-      <%= number_field_tag :percentage, flag.gates.find { |gate| gate["key"] == "percentage_of_actors" }&.fetch("value", nil), min: 0, max: 100 %>
-    </div>
-    <div>
-      <label>Group</label>
-      <%= select_tag :group_name, options_for_select(Onni::Group.names), include_blank: true %>
-      <%= select_tag :group_action, options_for_select([%w[Enable enable], %w[Disable disable]]), include_blank: "Action" %>
-    </div>
-    <div>
-      <label>A/B variants (name and weight)</label>
-      <div class="flex gap-2 items-end">
-        <div>
-          <label for="variant_control">control</label>
-          <%= number_field_tag "variants[control]", variants["control"], min: 0, max: 100, id: "variant_control" %>
-        </div>
-        <div>
-          <label for="variant_treatment">treatment</label>
-          <%= number_field_tag "variants[treatment]", variants["treatment"], min: 0, max: 100, id: "variant_treatment" %>
-        </div>
-      </div>
-    </div>
-    <%= submit_tag "Save", class: "button" %>
-  <% end %>
-
-  <%= render partial: "admin/features/stats", locals: { chart: @hit_chart, flag: flag } %>
-
-  <p class="mt-4"><%= link_to "Back to features", admin_features_path %></p>
-</div>