code_sunset 0.1.0

data/app/controllers/code_sunset/application_controller.rb

@@ -0,0 +1,50 @@
+module CodeSunset
+  class ApplicationController < ActionController::Base
+    layout "code_sunset/application"
+
+    before_action :authorize_dashboard!
+    helper_method :filters, :analytics_filters
+
+    private
+
+    def authorize_dashboard!
+      authorizer = CodeSunset.configuration.dashboard_authorizer
+      allowed = if authorizer.respond_to?(:call)
+        authorizer.arity.zero? ? instance_exec(&authorizer) : authorizer.call(self)
+      else
+        false
+      end
+
+      return if allowed
+
+      head :forbidden
+    rescue StandardError => error
+      CodeSunset.log_error("dashboard authorization", error)
+      head :forbidden
+    end
+
+    def filters
+      @filters ||= params.permit(*permitted_filter_keys).to_h.symbolize_keys
+    end
+
+    def analytics_filters
+      @analytics_filters ||= CodeSunset::AnalyticsFilters.new(filters)
+    end
+
+    def permitted_filter_keys
+      [
+        :app_env,
+        :plan,
+        :org_id,
+        :user_id,
+        :from,
+        :to,
+        :paid_only,
+        :exclude_internal,
+        :window,
+        :page,
+        *CodeSunset.configuration.custom_filters.keys
+      ]
+    end
+  end
+end

data/app/controllers/code_sunset/dashboard_controller.rb

@@ -0,0 +1,12 @@
+module CodeSunset
+  class DashboardController < ApplicationController
+    def index
+      @summaries = CodeSunset::FeatureQuery.new(filters).call
+      @active_count = @summaries.count { |summary| summary.status == "active" }
+      @removable_count = @summaries.count { |summary| %w[candidate_for_removal safe_to_remove].include?(summary.status) }
+      @recent_features = @summaries.select { |summary| summary.hits_7d.to_i.positive? }.sort_by { |summary| [-summary.hits_7d.to_i, summary.feature.key] }.first(6)
+      @safe_to_remove = @summaries.select { |summary| summary.status == "safe_to_remove" }.sort_by { |summary| [-summary.score.to_f, summary.feature.key] }.first(4)
+      @cooling_down = @summaries.select { |summary| summary.status == "candidate_for_removal" }.sort_by { |summary| [-summary.score.to_f, summary.feature.key] }.first(4)
+    end
+  end
+end

data/app/controllers/code_sunset/features_controller.rb

@@ -0,0 +1,62 @@
+module CodeSunset
+  class FeaturesController < ApplicationController
+    RECENT_EVENTS_PER_PAGE = 25
+
+    before_action :load_feature, only: :show
+
+    def index
+      @summaries = CodeSunset::FeatureQuery.new(filters).call
+    end
+
+    def show
+      @summary = CodeSunset::FeatureQuery.new(filters, scope: CodeSunset::Feature.where(id: @feature.id)).call.first
+      @usage_series = CodeSunset::FeatureUsageSeries.new(feature: @feature, filters: filters).call
+
+      scoped_events = @feature.events.apply_filters(filters).where(occurred_at: 30.days.ago..Time.current)
+      @top_orgs = CodeSunset::Event.top_orgs(scoped_events, limit: 8)
+      @top_users = CodeSunset::Event.top_users(scoped_events, limit: 8)
+      @request_paths = CodeSunset::Event.top_request_paths(scoped_events, limit: 8)
+      @job_usage = CodeSunset::Event.top_job_classes(scoped_events, limit: 8)
+
+      recent_events_scope = @feature.events.apply_filters(filters.except(:page)).recent_first
+      @recent_events_page = requested_recent_events_page
+      @recent_events_per_page = RECENT_EVENTS_PER_PAGE
+      @recent_events_total_count = recent_events_scope.count
+      @recent_events_total_pages = [(@recent_events_total_count.to_f / @recent_events_per_page).ceil, 1].max
+      @recent_events_page = [@recent_events_page, @recent_events_total_pages].min
+      @recent_events = recent_events_scope.offset((@recent_events_page - 1) * @recent_events_per_page).limit(@recent_events_per_page)
+
+      @removal_prompt_artifact = build_removal_prompt_artifact if generate_removal_prompt?
+    end
+
+    private
+
+    def load_feature
+      @feature = CodeSunset::Feature.find_by!(key: params[:id])
+    end
+
+    def requested_recent_events_page
+      page = params[:page].to_i
+      page.positive? ? page : 1
+    end
+
+    def generate_removal_prompt?
+      ActiveModel::Type::Boolean.new.cast(params[:generate_removal_prompt])
+    end
+
+    def build_removal_prompt_artifact
+      CodeSunset::RemovalPromptBuilder.new(
+        feature: @feature,
+        snapshot: @summary,
+        filters: filters,
+        top_orgs: @top_orgs,
+        top_users: @top_users,
+        request_paths: @request_paths,
+        job_usage: @job_usage,
+        recent_events: @recent_events,
+        recent_events_total_count: @recent_events_total_count,
+        usage_series: @usage_series
+      ).call
+    end
+  end
+end

data/app/controllers/code_sunset/removal_candidates_controller.rb

@@ -0,0 +1,9 @@
+module CodeSunset
+  class RemovalCandidatesController < ApplicationController
+    def index
+      @summaries = CodeSunset::RemovalCandidateQuery.new(filters).call
+      @safe = @summaries.select { |summary| summary.status == "safe_to_remove" }
+      @candidates = @summaries.select { |summary| summary.status == "candidate_for_removal" }
+    end
+  end
+end

data/app/helpers/code_sunset/application_helper.rb

@@ -0,0 +1,244 @@
+module CodeSunset
+  module ApplicationHelper
+    def format_seen_at(timestamp)
+      return "Never" unless timestamp
+
+      time = timestamp.in_time_zone
+      relative_time = if time > Time.current
+        "just now"
+      else
+        "#{time_ago_in_words(time)} ago"
+      end
+
+      content_tag(
+        :time,
+        relative_time,
+        class: "cs-time",
+        datetime: time.iso8601,
+        title: time.strftime("%Y-%m-%d %H:%M:%S %Z")
+      )
+    end
+
+    def human_count(value)
+      number_with_delimiter(value || 0)
+    end
+
+    def status_badge(status)
+      content_tag(:span, status.to_s.tr("_", " ").titleize, class: "cs-badge cs-badge--#{status}")
+    end
+
+    def current_filter_value(key)
+      filters[key]
+    end
+
+    def analytics_notice
+      analytics_filters.raw_filter_notice
+    end
+
+    def filters_applied?
+      filters.except(:page).values.any?(&:present?)
+    end
+
+    def sidebar_nav_link(label, path, icon:)
+      classes = ["cs-nav__link"]
+      classes << "is-active" if current_page?(path)
+
+      link_to path, class: classes.join(" ") do
+        safe_join(
+          [
+            content_tag(:span, sidebar_icon(icon), class: "cs-nav__icon"),
+            content_tag(:span, label, class: "cs-nav__text")
+          ]
+        )
+      end
+    end
+
+    def removal_score_badge(feature, snapshot, label: nil)
+      label ||= format("%.1f", snapshot&.score.to_f)
+
+      content_tag(
+        :span,
+        label,
+        class: "cs-score cs-score--help",
+        title: removal_score_tooltip(feature, snapshot)
+      )
+    end
+
+    def removal_score_tooltip(feature, snapshot)
+      return "Removal score is unavailable until usage has been analyzed." unless feature && snapshot
+
+      calculator = CodeSunset::ScoreCalculator.new(feature: feature, snapshot: snapshot)
+      breakdown = calculator.breakdown
+
+      [
+        "Removal score favors features that look safer to remove.",
+        "Recency: #{format('%.1f', breakdown[:recency][:score])}/#{format('%.0f', breakdown[:recency][:max])} from #{breakdown[:recency][:detail]}",
+        "Volume: #{format('%.1f', breakdown[:volume][:score])}/#{format('%.0f', breakdown[:volume][:max])} from #{breakdown[:volume][:detail]}",
+        "Org breadth: #{format('%.1f', breakdown[:orgs][:score])}/#{format('%.0f', breakdown[:orgs][:max])} from #{breakdown[:orgs][:detail]}",
+        "Paid usage: #{format('%.1f', breakdown[:paid_usage][:score])}/#{format('%.0f', breakdown[:paid_usage][:max])} from #{breakdown[:paid_usage][:detail]}",
+        "Total: #{format('%.1f', calculator.score)}/100"
+      ].join("\n")
+    end
+
+    def usage_chart(points)
+      return content_tag(:p, "No usage data yet.", class: "cs-subtle") if points.blank?
+
+      labels = points.keys.map { |day| day.strftime("%b %-d") }
+      values = points.values.map(&:to_i)
+
+      content_tag(:div, class: "cs-chart-shell") do
+        content_tag(
+          :canvas,
+          nil,
+          class: "cs-chart",
+          role: "img",
+          aria: { label: "Feature usage trend chart" },
+          data: {
+            code_sunset_usage_chart: true,
+            labels: labels.to_json,
+            values: values.to_json
+          }
+        )
+      end
+    end
+
+    def pagination_link_for(feature, label, page:, current:, filters: {}, rel: nil)
+      classes = ["cs-pagination__link"]
+      classes << "is-active" if current
+
+      link_to label, feature_path(feature.key, filters.merge(page: page)), class: classes.join(" "), rel: rel
+    end
+
+    def removal_prompt_path_for(feature)
+      feature_path(feature.key, filters.merge(generate_removal_prompt: true))
+    end
+
+    def removal_prompt_reset_path_for(feature)
+      feature_path(feature.key, filters.except(:page))
+    end
+
+    def filter_query_values(overrides = {})
+      filters.except(:page).merge(overrides).reject { |_key, value| value.blank? }
+    end
+
+    def filter_path_for(path, values = filter_query_values)
+      query_values = values.reject { |_key, value| value.blank? }
+      return path if query_values.empty?
+
+      "#{path}?#{query_values.to_query}"
+    end
+
+    def active_filter_chips_for(path)
+      filters.except(:page).each_with_object([]) do |(key, value), chips|
+        next if value.blank?
+
+        chips << {
+          key: key,
+          label: filter_chip_label(key),
+          value: filter_chip_value(key, value),
+          clear_path: filter_path_for(path, filters.except(:page, key))
+        }
+      end
+    end
+
+    def render_filter_bar(form_url:, reset_url:, title: "Filters", copy: nil)
+      render(
+        "code_sunset/shared/filter_bar",
+        form_url: form_url,
+        reset_url: reset_url,
+        title: title,
+        copy: copy,
+        filters_applied: filters_applied?,
+        active_chips: active_filter_chips_for(reset_url)
+      )
+    end
+
+    def advanced_filters_open?
+      filters.values_at(:plan, :org_id, :user_id, :paid_only, :exclude_internal, *configured_custom_filter_keys).any?(&:present?)
+    end
+
+    def configured_custom_filters
+      CodeSunset.configuration.custom_filters
+    end
+
+    def configured_custom_filter_keys
+      configured_custom_filters.keys
+    end
+
+    def custom_filter_input_tag(key, definition)
+      current_value = current_filter_value(key)
+
+      case definition[:type].to_sym
+      when :boolean
+        select_tag key, options_for_select([["Any", nil], ["Yes", true], ["No", false]], current_value), include_blank: false
+      when :select
+        select_tag key, options_for_select([["Any", nil]] + Array(definition[:options]), current_value), include_blank: false
+      else
+        text_field_tag key, current_value, placeholder: definition[:placeholder]
+      end
+    end
+
+    private
+
+    def filter_chip_label(key)
+      configured = configured_custom_filters[key.to_sym]
+      return configured[:label] if configured
+
+      {
+        app_env: "Environment",
+        plan: "Plan",
+        org_id: "Org",
+        user_id: "User",
+        from: "From",
+        to: "To",
+        paid_only: "Paid",
+        exclude_internal: "Internal"
+      }.fetch(key.to_sym, key.to_s.humanize)
+    end
+
+    def filter_chip_value(key, value)
+      configured = configured_custom_filters[key.to_sym]
+      if configured
+        return truthy_filter_label(value) if configured[:type].to_sym == :boolean
+
+        if configured[:type].to_sym == :select && configured[:options].present?
+          matched = configured[:options].find { |label, option_value| option_value.to_s == value.to_s }
+          return matched.first if matched
+        end
+
+        return value
+      end
+
+      case key.to_sym
+      when :paid_only
+        truthy_filter_label(value)
+      when :exclude_internal
+        truthy_filter_label(value, truthy: "Excluded", falsey: "Included")
+      else
+        value
+      end
+    end
+
+    def truthy_filter_label(value, truthy: "Yes", falsey: "No")
+      ActiveModel::Type::Boolean.new.cast(value) ? truthy : falsey
+    end
+
+    def sidebar_icon(name)
+      path =
+        case name.to_sym
+        when :dashboard
+          "M3.75 4.5h6.75v6.75H3.75zm9.75 0h6.75v4.5H13.5zm0 7.5h6.75v8.25H13.5zm-9.75 2.25h6.75V20.25H3.75z"
+        when :features
+          "M4.5 6.75A2.25 2.25 0 0 1 6.75 4.5h10.5a2.25 2.25 0 0 1 2.25 2.25v10.5a2.25 2.25 0 0 1-2.25 2.25H6.75A2.25 2.25 0 0 1 4.5 17.25zm3 2.25h9m-9 3.75h9m-9 3.75h5.25"
+        when :removal_queue
+          "M9 3.75h6m-7.5 4.5h9m-10.5 4.5h12m-10.5 4.5h9"
+        else
+          "M4.5 12h15"
+        end
+
+      content_tag(:svg, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "1.75", "stroke-linecap": "round", "stroke-linejoin": "round", aria: { hidden: true }) do
+        content_tag(:path, nil, d: path)
+      end
+    end
+  end
+end

data/app/jobs/code_sunset/aggregate_daily_rollups_job.rb

@@ -0,0 +1,48 @@
+module CodeSunset
+  class AggregateDailyRollupsJob < ApplicationJob
+    queue_as :default
+
+    def perform(start_date: nil, end_date: nil)
+      range = normalize_range(start_date, end_date)
+      relation = CodeSunset::Event.where(occurred_at: range)
+
+      rows = relation
+        .group(:feature_key, :app_env, Arel.sql("DATE(occurred_at)"))
+        .pluck(
+          :feature_key,
+          :app_env,
+          Arel.sql("DATE(occurred_at)"),
+          Arel.sql("COUNT(*)"),
+          Arel.sql("COUNT(DISTINCT #{CodeSunset::Event.user_identifier_expression})"),
+          Arel.sql("COUNT(DISTINCT #{CodeSunset::Event.org_identifier_expression})"),
+          Arel.sql("MAX(occurred_at)")
+        )
+
+      upserts = rows.map do |feature_key, app_env, day, hits_count, unique_users_count, unique_orgs_count, last_seen_at|
+        {
+          feature_key: feature_key,
+          app_env: app_env,
+          day: day,
+          hits_count: hits_count,
+          unique_users_count: unique_users_count,
+          unique_orgs_count: unique_orgs_count,
+          last_seen_at: last_seen_at,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+
+      return if upserts.empty?
+
+      CodeSunset::DailyRollup.upsert_all(upserts, unique_by: %i[feature_key app_env day])
+    end
+
+    private
+
+    def normalize_range(start_date, end_date)
+      from = start_date.present? ? Time.zone.parse(start_date.to_s).beginning_of_day : 30.days.ago.beginning_of_day
+      to = end_date.present? ? Time.zone.parse(end_date.to_s).end_of_day : Time.current.end_of_day
+      from..to
+    end
+  end
+end

data/app/jobs/code_sunset/application_job.rb

@@ -0,0 +1,4 @@
+module CodeSunset
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/code_sunset/cleanup_events_job.rb

@@ -0,0 +1,10 @@
+module CodeSunset
+  class CleanupEventsJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      cutoff = CodeSunset.configuration.event_retention_days.days.ago
+      CodeSunset::Event.where("occurred_at < ?", cutoff).delete_all
+    end
+  end
+end

data/app/jobs/code_sunset/evaluate_alerts_job.rb

@@ -0,0 +1,15 @@
+module CodeSunset
+  class EvaluateAlertsJob < ApplicationJob
+    queue_as :default
+
+    def perform(feature_key = nil)
+      if feature_key.present?
+        CodeSunset::AlertDispatcher.new(feature_key).dispatch_if_due
+      else
+        CodeSunset::Feature.find_each do |feature|
+          CodeSunset::AlertDispatcher.new(feature.key).dispatch_if_due
+        end
+      end
+    end
+  end
+end

data/app/jobs/code_sunset/flush_buffered_events_job.rb

@@ -0,0 +1,9 @@
+module CodeSunset
+  class FlushBufferedEventsJob < ApplicationJob
+    queue_as :default
+
+    def perform(limit: nil)
+      CodeSunset::EventIngestor.flush_buffer(limit: limit)
+    end
+  end
+end

data/app/jobs/code_sunset/persist_event_job.rb

@@ -0,0 +1,9 @@
+module CodeSunset
+  class PersistEventJob < ApplicationJob
+    queue_as :default
+
+    def perform(payload)
+      CodeSunset::Event.create_from_payload(payload)
+    end
+  end
+end

data/app/mailers/code_sunset/application_mailer.rb

@@ -0,0 +1,6 @@
+module CodeSunset
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/code_sunset/alert_delivery.rb

@@ -0,0 +1,14 @@
+module CodeSunset
+  class AlertDelivery < ApplicationRecord
+    self.table_name = "code_sunset_alert_deliveries"
+
+    validates :feature_key, :status, :alert_kind, :delivered_at, presence: true
+
+    class << self
+      def recent_for(feature_key:, status:, alert_kind:, since:)
+        where(feature_key: feature_key, status: status, alert_kind: alert_kind)
+          .where("delivered_at >= ?", since)
+      end
+    end
+  end
+end

data/app/models/code_sunset/application_record.rb

@@ -0,0 +1,5 @@
+module CodeSunset
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/code_sunset/daily_rollup.rb

@@ -0,0 +1,31 @@
+module CodeSunset
+  class DailyRollup < ApplicationRecord
+    self.table_name = "code_sunset_daily_rollups"
+
+    belongs_to :feature, primary_key: :key, foreign_key: :feature_key, inverse_of: :daily_rollups, optional: true
+
+    validates :feature_key, :day, presence: true
+    validates :feature_key, uniqueness: { scope: [:app_env, :day] }
+
+    scope :ordered, -> { order(day: :asc) }
+
+    class << self
+      def apply_filters(filters = {})
+        normalized = filters.to_h.symbolize_keys
+        scoped = all
+        scoped = scoped.where(app_env: normalized[:app_env]) if normalized[:app_env].present?
+        scoped = scoped.where(day: parse_date(normalized[:from])..) if normalized[:from].present? && parse_date(normalized[:from])
+        scoped = scoped.where(day: ..parse_date(normalized[:to])) if normalized[:to].present? && parse_date(normalized[:to])
+        scoped
+      end
+
+      private
+
+      def parse_date(value)
+        Date.parse(value.to_s)
+      rescue Date::Error
+        nil
+      end
+    end
+  end
+end