code_sunset 0.1.0

data/app/models/code_sunset/event.rb

@@ -0,0 +1,190 @@
+module CodeSunset
+  class Event < ApplicationRecord
+    self.table_name = "code_sunset_events"
+
+    belongs_to :feature, primary_key: :key, foreign_key: :feature_key, inverse_of: :events, optional: true
+
+    validates :feature_key, presence: true
+    validates :occurred_at, presence: true
+
+    before_validation :apply_defaults
+
+    scope :recent_first, -> { order(occurred_at: :desc) }
+
+    class << self
+      def create_from_payload(payload)
+        attrs = sanitize_payload(payload)
+
+        transaction do
+          CodeSunset::Feature.find_or_create_by!(key: attrs[:feature_key])
+          create!(attrs)
+        end
+      end
+
+      def apply_filters(filters = {})
+        scoped = all
+        normalized = filters.to_h.symbolize_keys
+
+        scoped = scoped.where(app_env: normalized[:app_env]) if normalized[:app_env].present?
+        scoped = scoped.where(plan: normalized[:plan]) if normalized[:plan].present?
+        if normalized[:org_id].present?
+          scoped = apply_identity_filter(scoped, :org_id, :hashed_org_id, normalized[:org_id])
+        end
+        if normalized[:user_id].present?
+          scoped = apply_identity_filter(scoped, :user_id, :hashed_user_id, normalized[:user_id])
+        end
+        scoped = scoped.where(paid_org: true) if truthy?(normalized[:paid_only])
+        scoped = scoped.where.not(internal_org: true) if truthy?(normalized[:exclude_internal])
+        scoped = apply_custom_metadata_filters(scoped, normalized)
+
+        from_time = parse_time(normalized[:from])&.beginning_of_day
+        to_time = parse_time(normalized[:to])&.end_of_day
+
+        scoped = scoped.where(occurred_at: from_time..) if from_time
+        scoped = scoped.where(occurred_at: ..to_time) if to_time
+        scoped
+      end
+
+      def grouped_last_seen(scope)
+        scope.group(:feature_key).maximum(:occurred_at)
+      end
+
+      def grouped_counts(scope)
+        scope.group(:feature_key).count
+      end
+
+      def grouped_distinct_org_counts(scope)
+        scope.group(:feature_key).distinct.count(Arel.sql(org_identifier_expression))
+      end
+
+      def grouped_distinct_user_counts(scope)
+        scope.group(:feature_key).distinct.count(Arel.sql(user_identifier_expression))
+      end
+
+      def top_request_paths(scope, limit: 10)
+        grouped_top(scope.where.not(request_path: [nil, ""]), "request_path", limit: limit)
+      end
+
+      def top_job_classes(scope, limit: 10)
+        grouped_top(scope.where.not(job_class: [nil, ""]), "job_class", limit: limit)
+      end
+
+      def top_orgs(scope, limit: 10)
+        grouped_top(scope, org_identifier_expression, limit: limit, alias_name: "org_identifier")
+      end
+
+      def top_users(scope, limit: 10)
+        grouped_top(scope, user_identifier_expression, limit: limit, alias_name: "user_identifier")
+      end
+
+      def org_identifier_expression
+        "COALESCE(code_sunset_events.hashed_org_id, code_sunset_events.org_id::text)"
+      end
+
+      def user_identifier_expression
+        "COALESCE(code_sunset_events.hashed_user_id, code_sunset_events.user_id::text)"
+      end
+
+      private
+
+      def sanitize_payload(payload)
+        attrs = payload.to_h.symbolize_keys.slice(
+          :feature_key,
+          :occurred_at,
+          :user_id,
+          :org_id,
+          :request_id,
+          :source,
+          :request_path,
+          :controller,
+          :action,
+          :job_class,
+          :app_env,
+          :app_version,
+          :metadata,
+          :plan,
+          :internal_org,
+          :paid_org
+        )
+        attrs[:metadata] = attrs.fetch(:metadata, {}).to_h
+
+        if CodeSunset.configuration.hash_identity
+          apply_identity_hash!(attrs, :user_id, :hashed_user_id)
+          apply_identity_hash!(attrs, :org_id, :hashed_org_id)
+        end
+
+        attrs
+      end
+
+      def apply_identity_hash!(attrs, source_key, target_key)
+        return unless CodeSunset.configuration.identity_fields.include?(source_key)
+        return if attrs[source_key].blank?
+
+        attrs[target_key] = CodeSunset::IdentityHash.digest(attrs[source_key])
+        attrs[source_key] = nil
+      end
+
+      def grouped_top(scope, expression, limit:, alias_name: "identifier")
+        scope
+          .select("#{expression} AS #{alias_name}", "COUNT(*) AS hits")
+          .where(Arel.sql("#{expression} IS NOT NULL"))
+          .group(alias_name)
+          .order("hits DESC")
+          .limit(limit)
+          .map { |row| [row.public_send(alias_name), row.hits.to_i] }
+      end
+
+      def apply_custom_metadata_filters(scope, filters)
+        CodeSunset.configuration.custom_filters.each do |param_key, definition|
+          next unless filters[param_key].present?
+
+          metadata_key = definition[:metadata_key]
+          case definition[:type].to_sym
+          when :boolean
+            scope = scope.where("code_sunset_events.metadata ->> ? = ?", metadata_key, truthy?(filters[param_key]).to_s)
+          else
+            scope = scope.where("code_sunset_events.metadata ->> ? = ?", metadata_key, filters[param_key].to_s)
+          end
+        end
+
+        scope
+      end
+
+      def apply_identity_filter(scope, raw_key, hashed_key, value)
+        if CodeSunset.configuration.hash_identity && CodeSunset.configuration.identity_fields.include?(raw_key)
+          scope.where(hashed_key => CodeSunset::IdentityHash.digest(value))
+        else
+          scope.where(raw_key => value)
+        end
+      end
+
+      def parse_time(value)
+        return if value.blank?
+
+        Time.zone.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def truthy?(value)
+        ActiveModel::Type::Boolean.new.cast(value)
+      end
+    end
+
+    def display_org_identifier
+      hashed_org_id.presence || org_id&.to_s
+    end
+
+    def display_user_identifier
+      hashed_user_id.presence || user_id&.to_s
+    end
+
+    private
+
+    def apply_defaults
+      self.app_env = CodeSunset.configuration.environment if app_env.blank?
+      self.metadata = metadata.to_h if metadata.present?
+      self.metadata ||= {}
+    end
+  end
+end

data/app/models/code_sunset/feature.rb

@@ -0,0 +1,33 @@
+module CodeSunset
+  class Feature < ApplicationRecord
+    self.table_name = "code_sunset_features"
+
+    STATUSES = %w[active cooling_down candidate_for_removal safe_to_remove].freeze
+
+    has_many :events, primary_key: :key, foreign_key: :feature_key, inverse_of: :feature, dependent: :nullify
+    has_many :daily_rollups, primary_key: :key, foreign_key: :feature_key, inverse_of: :feature, dependent: :delete_all
+
+    validates :key, presence: true, uniqueness: true
+    validates :status, inclusion: { in: STATUSES }, allow_blank: true
+
+    before_validation :apply_defaults
+
+    scope :ordered, -> { order(:key) }
+
+    def computed_status(last_seen_at: nil, reference_time: Time.current)
+      CodeSunset::StatusEngine.new(feature: self, last_seen_at: last_seen_at, reference_time: reference_time).status
+    end
+
+    def removal_score(snapshot = nil)
+      snapshot ||= CodeSunset::FeatureQuery.new({}, scope: self.class.where(id: id)).call.first
+      CodeSunset::ScoreCalculator.new(feature: self, snapshot: snapshot).score
+    end
+
+    private
+
+    def apply_defaults
+      self.sunset_after_days = 90 if sunset_after_days.blank?
+      self.remove_after_days_unused = 60 if remove_after_days_unused.blank?
+    end
+  end
+end

data/app/views/code_sunset/dashboard/index.html.erb

@@ -0,0 +1,123 @@
+<section class="cs-page-header">
+  <div>
+    <h2 class="cs-page-title">Overview</h2>
+    <p class="cs-page-copy">Start with what is active this week, then review what looks ready to retire.</p>
+  </div>
+  <div class="cs-page-actions cs-page-actions--compact">
+    <%= link_to "Features", features_path, class: "cs-inline-link" %>
+    <%= link_to "Review Removal Queue", removal_candidates_path, class: "cs-button cs-button--secondary" %>
+  </div>
+</section>
+
+<section class="cs-grid">
+  <article class="cs-stat">
+    <p class="cs-stat__label">Tracked Features</p>
+    <p class="cs-stat__value"><%= human_count(@summaries.count) %></p>
+    <p class="cs-stat__hint">Registered or observed.</p>
+  </article>
+  <article class="cs-stat">
+    <p class="cs-stat__label">Active Features</p>
+    <p class="cs-stat__value"><%= human_count(@active_count) %></p>
+    <p class="cs-stat__hint">Still seeing traffic.</p>
+  </article>
+  <article class="cs-stat">
+    <p class="cs-stat__label">Removable Features</p>
+    <p class="cs-stat__value"><%= human_count(@removable_count) %></p>
+    <p class="cs-stat__hint">Candidate or safe to remove.</p>
+  </article>
+</section>
+
+<section class="cs-overview-layout">
+  <article class="cs-panel">
+    <div class="cs-panel__heading">
+      <div>
+        <h2>Active This Week</h2>
+      </div>
+      <span class="cs-panel__count"><%= human_count(@recent_features.count) %> features</span>
+    </div>
+    <p class="cs-panel__copy">A quick pulse on the busiest legacy paths before you drill into the full feature inventory.</p>
+    <div class="cs-table-wrap">
+      <table class="cs-table">
+        <thead>
+          <tr>
+            <th>Feature</th>
+            <th>Status</th>
+            <th>Hits 7d</th>
+            <th>Last Seen</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @recent_features.each do |summary| %>
+            <tr>
+              <td><%= link_to summary.feature.key, feature_path(summary.feature.key), class: "cs-code" %></td>
+              <td><%= status_badge(summary.status) %></td>
+              <td><%= human_count(summary.hits_7d) %></td>
+              <td><%= format_seen_at(summary.last_seen_at) %></td>
+            </tr>
+          <% end %>
+          <% if @recent_features.empty? %>
+            <tr>
+              <td colspan="4" class="cs-subtle">No recent feature usage has been recorded yet.</td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  </article>
+
+  <div class="cs-stack">
+    <article class="cs-panel">
+      <div class="cs-panel__heading">
+        <div>
+          <h2>Ready To Review</h2>
+        </div>
+        <span class="cs-panel__count"><%= human_count(@safe_to_remove.count) %> items</span>
+      </div>
+      <p class="cs-panel__copy">Highest-confidence removals based on inactivity, low breadth, and low paid usage.</p>
+
+      <ul class="cs-queue-list">
+        <% @safe_to_remove.each do |summary| %>
+          <li class="cs-queue-list__item">
+            <div class="cs-queue-list__body">
+              <%= link_to summary.feature.key, feature_path(summary.feature.key), class: "cs-code cs-queue-list__title" %>
+              <p class="cs-queue-list__meta">Last seen <%= format_seen_at(summary.last_seen_at) %></p>
+            </div>
+            <div class="cs-queue-list__aside">
+              <%= removal_score_badge(summary.feature, summary, label: "Score #{summary.score.round(1)}") %>
+            </div>
+          </li>
+        <% end %>
+        <% if @safe_to_remove.empty? %>
+          <li class="cs-subtle">Nothing is confidently removable yet.</li>
+        <% end %>
+      </ul>
+    </article>
+
+    <article class="cs-panel">
+      <div class="cs-panel__heading">
+        <div>
+          <h2>Cooling Down</h2>
+        </div>
+        <span class="cs-panel__count"><%= human_count(@cooling_down.count) %> items</span>
+      </div>
+      <p class="cs-panel__copy">Features that still have some recent traffic, but are trending toward the removal queue.</p>
+
+      <ul class="cs-queue-list">
+        <% @cooling_down.each do |summary| %>
+          <li class="cs-queue-list__item">
+            <div class="cs-queue-list__body">
+              <%= link_to summary.feature.key, feature_path(summary.feature.key), class: "cs-code cs-queue-list__title" %>
+              <p class="cs-queue-list__meta"><%= human_count(summary.hits_30d) %> hits in the last 30 days</p>
+            </div>
+            <div class="cs-queue-list__aside">
+              <%= removal_score_badge(summary.feature, summary, label: "Score #{summary.score.round(1)}") %>
+            </div>
+          </li>
+        <% end %>
+        <% if @cooling_down.empty? %>
+          <li class="cs-subtle">No features are currently in the cooldown queue.</li>
+        <% end %>
+      </ul>
+    </article>
+  </div>
+</section>

data/app/views/code_sunset/features/index.html.erb

@@ -0,0 +1,88 @@
+<% active_count = @summaries.count { |summary| summary.status == "active" } %>
+<% removable_count = @summaries.count { |summary| %w[candidate_for_removal safe_to_remove].include?(summary.status) } %>
+
+<section class="cs-page-header">
+  <div>
+    <h2 class="cs-page-title">Features</h2>
+    <p class="cs-page-copy">Scan the inventory, then narrow it with filters when you need a closer look.</p>
+  </div>
+  <div class="cs-page-actions cs-page-actions--compact">
+    <% if filters_applied? %>
+      <%= link_to "Reset Filters", features_path, class: "cs-inline-link" %>
+    <% end %>
+  </div>
+</section>
+
+<section class="cs-grid">
+  <article class="cs-stat">
+    <p class="cs-stat__label">Features</p>
+    <p class="cs-stat__value"><%= human_count(@summaries.count) %></p>
+    <p class="cs-stat__hint">Visible in the current view.</p>
+  </article>
+  <article class="cs-stat">
+    <p class="cs-stat__label">Active</p>
+    <p class="cs-stat__value"><%= human_count(active_count) %></p>
+    <p class="cs-stat__hint">Still seeing traffic.</p>
+  </article>
+  <article class="cs-stat">
+    <p class="cs-stat__label">Review Soon</p>
+    <p class="cs-stat__value"><%= human_count(removable_count) %></p>
+    <p class="cs-stat__hint">Candidate or safe to remove.</p>
+  </article>
+</section>
+
+<%= render_filter_bar(
+  form_url: features_path,
+  reset_url: features_path,
+  title: "Filters",
+  copy: "Environment and dates use rollups where possible. Org, user, plan, internal, and custom metadata filters use retained raw events."
+) %>
+
+<section class="cs-panel">
+  <div class="cs-panel__heading">
+    <div>
+      <h2>Feature Inventory</h2>
+    </div>
+    <span class="cs-panel__count"><%= human_count(@summaries.count) %></span>
+  </div>
+  <p class="cs-panel__copy">Use this table to decide what needs inspection now, then open a feature for the full drill-down.</p>
+
+  <div class="cs-table-wrap">
+    <table class="cs-table cs-table--features">
+      <thead>
+        <tr>
+          <th>Feature</th>
+          <th>Status</th>
+          <th>Last Seen</th>
+          <th>Activity</th>
+          <th>Orgs</th>
+          <th>Owner</th>
+          <th>Score</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @summaries.each do |summary| %>
+          <tr>
+            <td><%= link_to summary.feature.key, filter_path_for(feature_path(summary.feature.key)), class: "cs-code" %></td>
+            <td><%= status_badge(summary.status) %></td>
+            <td><%= format_seen_at(summary.last_seen_at) %></td>
+            <td>
+              <div class="cs-metric-pair">
+                <span class="cs-metric-pair__item"><strong><%= human_count(summary.hits_7d) %></strong><span>7d</span></span>
+                <span class="cs-metric-pair__item"><strong><%= human_count(summary.hits_30d) %></strong><span>30d</span></span>
+              </div>
+            </td>
+            <td><%= human_count(summary.unique_orgs_count) %></td>
+            <td><%= summary.feature.owner.presence || "Unassigned" %></td>
+            <td><%= removal_score_badge(summary.feature, summary, label: summary.score.round(1).to_s) %></td>
+          </tr>
+        <% end %>
+        <% if @summaries.empty? %>
+          <tr>
+            <td colspan="7" class="cs-subtle">No features matched the current filters.</td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+</section>