rails_pulse 0.1.4 → 0.2.3

data/app/controllers/concerns/tag_filter_concern.rb

@@ -0,0 +1,26 @@
+module TagFilterConcern
+  extend ActiveSupport::Concern
+
+  private
+
+  # Apply tag filters to a query
+  # Excludes records that have ANY of the disabled tags
+  def apply_tag_filters(query)
+    disabled_tags = session_disabled_tags
+    query = disabled_tags.reduce(query) do |q, tag|
+      q.without_tag(tag)
+    end
+
+    apply_non_tagged_filter(query)
+  end
+
+  # Apply non-tagged filter to a query
+  # If show_non_tagged is false, exclude records with no tags
+  def apply_non_tagged_filter(query)
+    if session[:show_non_tagged] == false
+      query.with_tags
+    else
+      query
+    end
+  end
+end

data/app/controllers/concerns/time_range_concern.rb

@@ -6,7 +6,8 @@ module TimeRangeConcern
     const_set(:TIME_RANGE_OPTIONS, [
       [ "Last 24 hours", :last_day ],
       [ "Last Week", :last_week ],
-      [ "Last Month", :last_month ]
+      [ "Last Month", :last_month ],
+      [ "Custom Range...", :custom ]
     ].freeze)
   end
 
@@ -17,11 +18,8 @@ module TimeRangeConcern
 
     ransack_params = params[:q] || {}
 
-    if ransack_params[:occurred_at_gteq].present?
-      # Custom time range from chart zoom where there is no association
-      start_time = parse_time_param(ransack_params[:occurred_at_gteq])
-      end_time = parse_time_param(ransack_params[:occurred_at_lt])
-    elsif ransack_params[:period_start_range]
+    # Priority 1: Page-specific preset from dropdown (check this first!)
+    if ransack_params[:period_start_range].present? && ransack_params[:period_start_range].to_sym != :custom
       # Predefined time range from dropdown
       selected_time_range = ransack_params[:period_start_range]
       start_time =
@@ -31,7 +29,26 @@ module TimeRangeConcern
         when :last_month then 1.month.ago
         else 1.day.ago # Default fallback
         end
+    # Priority 2: Page-specific custom datetime range from picker (only if period_start_range is :custom)
+    elsif ransack_params[:period_start_range].present? && ransack_params[:period_start_range].to_sym == :custom && ransack_params[:custom_date_range].present? && ransack_params[:custom_date_range].include?(" to ")
+      # Custom datetime range from custom range picker
+      dates = ransack_params[:custom_date_range].split(" to ")
+      start_time = parse_time_param(dates[0].strip)
+      end_time = parse_time_param(dates[1].strip)
+      selected_time_range = :custom
+    # Priority 3: Page-specific filters (chart zoom)
+    elsif ransack_params[:occurred_at_gteq].present? && ransack_params[:occurred_at_lt].present?
+      # Custom time range from chart zoom
+      start_time = parse_time_param(ransack_params[:occurred_at_gteq])
+      end_time = parse_time_param(ransack_params[:occurred_at_lt])
+      selected_time_range = :custom
+    # Priority 4: Global filters (from session)
+    elsif session_global_filters["start_time"].present? || session_global_filters["end_time"].present?
+      start_time = parse_time_param(session_global_filters["start_time"]) if session_global_filters["start_time"].present?
+      end_time = parse_time_param(session_global_filters["end_time"]) if session_global_filters["end_time"].present?
+      selected_time_range = :custom
     end
+    # Priority 5: Default time range (already set above)
 
     time_diff = (end_time.to_i - start_time.to_i) / 3600.0
 
@@ -43,7 +60,7 @@ module TimeRangeConcern
       end_time = end_time.end_of_day
     end
 
-    [ start_time, end_time, selected_time_range, time_diff ]
+    [ start_time.to_i, end_time.to_i, selected_time_range, time_diff ]
   end
 
   private
@@ -53,7 +70,9 @@ module TimeRangeConcern
     when Time, DateTime
       param.in_time_zone
     when String
-      Time.zone.parse(param)
+      # Parse as server local time (not UTC, not Time.zone)
+      # This ensures flatpickr datetime strings are interpreted in server's timezone
+      Time.parse(param).localtime
     else
       # Assume it's an integer timestamp
       Time.zone.at(param.to_i)

data/app/controllers/rails_pulse/application_controller.rb

@@ -1,6 +1,8 @@
 module RailsPulse
   class ApplicationController < ActionController::Base
     before_action :authenticate_rails_pulse_user!
+    before_action :set_show_non_tagged_default
+    helper_method :session_global_filters, :session_disabled_tags
 
     def set_pagination_limit(limit = nil)
       limit = limit || params[:limit]
@@ -12,6 +14,49 @@ module RailsPulse
       end
     end
 
+    def set_global_filters
+      if params[:clear] == "true"
+        session.delete(:global_filters)
+        session[:show_non_tagged] = true  # Reset show_non_tagged to default
+      else
+        filters = session[:global_filters] || {}
+
+        # Update time filters if provided
+        if params[:start_time].present? && params[:end_time].present?
+          filters["start_time"] = params[:start_time]
+          filters["end_time"] = params[:end_time]
+        end
+
+        # Update performance threshold if provided (or remove if empty)
+        if params[:performance_threshold].present?
+          filters["performance_threshold"] = params[:performance_threshold]
+        else
+          filters.delete("performance_threshold")
+        end
+
+        # Update tag visibility - convert enabled tags to disabled tags
+        all_tags = RailsPulse.configuration.tags
+        enabled_tags = params[:enabled_tags] || []
+
+        # Handle "non_tagged" separately
+        session[:show_non_tagged] = enabled_tags.include?("non_tagged")
+        enabled_tags = enabled_tags - [ "non_tagged" ]
+
+        disabled_tags = all_tags - enabled_tags
+
+        if disabled_tags.any?
+          filters["disabled_tags"] = disabled_tags
+        else
+          filters.delete("disabled_tags")
+        end
+
+        session[:global_filters] = filters
+      end
+
+      # Redirect back to the referring page or root
+      redirect_back(fallback_location: root_path)
+    end
+
     private
 
     def authenticate_rails_pulse_user!
@@ -71,5 +116,34 @@ module RailsPulse
       validated_limit = limit.to_i.clamp(5, 50)
       session[:pagination_limit] = validated_limit if limit.present?
     end
+
+    def session_global_filters
+      session[:global_filters] || {}
+    end
+
+    def session_disabled_tags
+      session_global_filters["disabled_tags"] || []
+    end
+
+    # Get the minimum duration based on global performance threshold
+    # Returns nil if no threshold is set (show all)
+    # context: :route, :request, or :query
+    def global_performance_threshold_duration(context)
+      threshold = session_global_filters["performance_threshold"]
+      return nil unless threshold.present?
+
+      config_key = "#{context}_thresholds".to_sym
+      thresholds = RailsPulse.configuration.public_send(config_key)
+
+      thresholds[threshold.to_sym]
+    rescue StandardError => e
+      Rails.logger.warn "Failed to get performance threshold: #{e.message}"
+      nil
+    end
+
+    # Set default value for show_non_tagged if not already set
+    def set_show_non_tagged_default
+      session[:show_non_tagged] = true if session[:show_non_tagged].nil?
+    end
   end
 end

data/app/controllers/rails_pulse/dashboard_controller.rb

@@ -1,18 +1,22 @@
 module RailsPulse
   class DashboardController < ApplicationController
     def index
-      @average_query_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil).to_metric_card
-      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil).to_metric_card
-      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil).to_metric_card
-      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil).to_metric_card
+      # Get tag filter values from session
+      disabled_tags = session_disabled_tags
+      show_non_tagged = session[:show_non_tagged] != false
+
+      @average_query_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
 
       # Generate chart data for inline rendering
-      @average_response_time_chart_data = RailsPulse::Dashboard::Charts::AverageResponseTime.new.to_chart_data
-      @p95_response_time_chart_data = RailsPulse::Dashboard::Charts::P95ResponseTime.new.to_chart_data
+      @average_response_time_chart_data = RailsPulse::Dashboard::Charts::AverageResponseTime.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_chart_data
+      @p95_response_time_chart_data = RailsPulse::Dashboard::Charts::P95ResponseTime.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_chart_data
 
       # Generate table data for inline rendering
-      @slow_routes_table_data = RailsPulse::Dashboard::Tables::SlowRoutes.new.to_table_data
-      @slow_queries_table_data = RailsPulse::Dashboard::Tables::SlowQueries.new.to_table_data
+      @slow_routes_table_data = RailsPulse::Dashboard::Tables::SlowRoutes.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_table_data
+      @slow_queries_table_data = RailsPulse::Dashboard::Tables::SlowQueries.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_table_data
     end
   end
 end

data/app/controllers/rails_pulse/queries_controller.rb

@@ -1,6 +1,7 @@
 module RailsPulse
   class QueriesController < ApplicationController
     include ChartTableConcern
+    include TagFilterConcern
 
     before_action :set_query, only: [ :show, :analyze ]
 
@@ -69,7 +70,8 @@ module RailsPulse
     def build_chart_ransack_params(ransack_params)
       base_params = ransack_params.except(:s).merge(
         period_start_gteq: Time.at(@start_time),
-        period_start_lt: Time.at(@end_time)
+        period_start_lt: Time.at(@end_time),
+        summarizable_type_eq: "RailsPulse::Query"
       )
 
       # Only add duration filter if we have a meaningful threshold
@@ -77,8 +79,7 @@ module RailsPulse
 
       if show_action?
         base_params.merge(
-          summarizable_id_eq: @query.id,
-          summarizable_type_eq: "RailsPulse::Query"
+          summarizable_id_eq: @query.id
         )
       else
         base_params
@@ -114,13 +115,16 @@ module RailsPulse
     def build_table_results
       if show_action?
         # For Summary model on show page - ransack params already include query ID and type filters
+        # Summaries aren't taggable, so we don't apply tag filters here
         @ransack_query.result.where(period_type: period_type)
       else
         Queries::Tables::Index.new(
           ransack_query: @ransack_query,
           period_type: period_type,
           start_time: @start_time,
-          params: params
+          params: params,
+          disabled_tags: session_disabled_tags,
+          show_non_tagged: session[:show_non_tagged] != false
         ).to_table
       end
     end
@@ -130,9 +134,13 @@ module RailsPulse
     def setup_metric_cards
       return if turbo_frame_request?
 
-      @average_query_times_metric_card = RailsPulse::Queries::Cards::AverageQueryTimes.new(query: @query).to_metric_card
-      @percentile_query_times_metric_card = RailsPulse::Queries::Cards::PercentileQueryTimes.new(query: @query).to_metric_card
-      @execution_rate_metric_card = RailsPulse::Queries::Cards::ExecutionRate.new(query: @query).to_metric_card
+      # Get tag filter values from session
+      disabled_tags = session_disabled_tags
+      show_non_tagged = session[:show_non_tagged] != false
+
+      @average_query_times_metric_card = RailsPulse::Queries::Cards::AverageQueryTimes.new(query: @query, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @percentile_query_times_metric_card = RailsPulse::Queries::Cards::PercentileQueryTimes.new(query: @query, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @execution_rate_metric_card = RailsPulse::Queries::Cards::ExecutionRate.new(query: @query, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
     end
 
     def show_action?

data/app/controllers/rails_pulse/requests_controller.rb

@@ -1,6 +1,14 @@
 module RailsPulse
   class RequestsController < ApplicationController
     include ChartTableConcern
+    include TagFilterConcern
+
+    # Override TIME_RANGE_OPTIONS from TimeRangeConcern with requests-specific options
+    remove_const(:TIME_RANGE_OPTIONS) if const_defined?(:TIME_RANGE_OPTIONS)
+    TIME_RANGE_OPTIONS = [
+      [ "Recent", "recent" ],
+      [ "Custom Range", "custom" ]
+    ].freeze
 
     before_action :set_request, only: :show
 
@@ -18,10 +26,14 @@ module RailsPulse
     def setup_metric_cards
       return if  turbo_frame_request?
 
-      @average_response_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil).to_metric_card
-      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil).to_metric_card
-      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil).to_metric_card
-      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil).to_metric_card
+      # Get tag filter values from session
+      disabled_tags = session_disabled_tags
+      show_non_tagged = session[:show_non_tagged] != false
+
+      @average_response_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
     end
 
 
@@ -55,11 +67,32 @@ module RailsPulse
     end
 
     def build_table_ransack_params(ransack_params)
-      params = ransack_params.merge(
-        occurred_at_gteq: Time.at(@table_start_time),
-        occurred_at_lt: Time.at(@table_end_time)
-      )
-      params[:duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+      params = ransack_params.dup
+
+      # Handle time mode - check if recent mode is selected
+      time_mode = params[:period_start_range] || "recent"
+
+      if time_mode != "recent"
+        # Custom mode - apply time filters
+        params.merge!(
+          occurred_at_gteq: Time.at(@table_start_time),
+          occurred_at_lt: Time.at(@table_end_time)
+        )
+      end
+      # else: Recent mode - no time filters, just rely on sort + pagination
+
+      # Duration filter - convert symbol to numeric threshold or use @start_duration
+      if params[:duration_gteq].present?
+        # If it's a symbol like :slow, convert it to the numeric threshold
+        if params[:duration_gteq].to_s.in?(%w[slow very_slow critical])
+          params[:duration_gteq] = @start_duration
+        end
+        # else: it's already a number, keep it as is
+      elsif @start_duration && @start_duration > 0
+        # No duration_gteq param, use @start_duration from concern
+        params[:duration_gteq] = @start_duration
+      end
+
       params
     end
 
@@ -68,10 +101,13 @@ module RailsPulse
     end
 
     def build_table_results
-      base_query = @ransack_query.result.includes(:route)
+      base_query = apply_tag_filters(@ransack_query.result.includes(:route))
+
+      # If filtering or sorting by route_path, we need to join the routes table
+      needs_join = @ransack_query.sorts.any? { |sort| sort.name == "route_path" } ||
+                   params.dig(:q, :route_path_cont).present?
 
-      # If sorting by route_path, we need to join the routes table
-      if @ransack_query.sorts.any? { |sort| sort.name == "route_path" }
+      if needs_join
         base_query = base_query.joins(:route)
       end
 

data/app/controllers/rails_pulse/routes_controller.rb

@@ -1,6 +1,7 @@
 module RailsPulse
   class RoutesController < ApplicationController
     include ChartTableConcern
+    include TagFilterConcern
 
     before_action :set_route, only: :show
 
@@ -19,10 +20,14 @@ module RailsPulse
     def setup_metric_cards
       return if turbo_frame_request?
 
-      @average_query_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: @route).to_metric_card
-      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: @route).to_metric_card
-      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: @route).to_metric_card
-      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: @route).to_metric_card
+      # Get tag filter values from session
+      disabled_tags = session_disabled_tags
+      show_non_tagged = session[:show_non_tagged] != false
+
+      @average_query_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: @route, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: @route, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: @route, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
+      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: @route, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged).to_metric_card
     end
 
     def chart_model
@@ -86,6 +91,8 @@ module RailsPulse
       if show_action?
         # Only show requests that belong to time periods where we have route summaries
         # This ensures the table data is consistent with the chart data
+        # Note: We don't apply tag filters here because we want to show all requests
+        # for this specific route, regardless of individual request tags
         base_query = @ransack_query.result
           .joins(<<~SQL)
             INNER JOIN rails_pulse_summaries ON
@@ -108,7 +115,9 @@ module RailsPulse
           ransack_query: @ransack_query,
           period_type: period_type,
           start_time: @start_time,
-          params: params
+          params: params,
+          disabled_tags: session_disabled_tags,
+          show_non_tagged: session[:show_non_tagged] != false
         ).to_table
       end
     end

data/app/controllers/rails_pulse/tags_controller.rb

@@ -0,0 +1,51 @@
+module RailsPulse
+  class TagsController < ApplicationController
+    before_action :set_taggable
+
+    def create
+      tag = params[:tag]
+
+      if tag.blank?
+        render turbo_stream: turbo_stream.replace("tag_manager_#{@taggable.class.name.demodulize.underscore}_#{@taggable.id}",
+          partial: "rails_pulse/tags/tag_manager",
+          locals: { taggable: @taggable, error: "Tag cannot be blank" })
+        return
+      end
+
+      @taggable.add_tag(tag)
+      @taggable.reload
+
+      render turbo_stream: turbo_stream.replace("tag_manager_#{@taggable.class.name.demodulize.underscore}_#{@taggable.id}",
+        partial: "rails_pulse/tags/tag_manager",
+        locals: { taggable: @taggable })
+    end
+
+    def destroy
+      tag = params[:tag]
+      @taggable.remove_tag(tag)
+      @taggable.reload
+
+      render turbo_stream: turbo_stream.replace("tag_manager_#{@taggable.class.name.demodulize.underscore}_#{@taggable.id}",
+        partial: "rails_pulse/tags/tag_manager",
+        locals: { taggable: @taggable })
+    end
+
+    private
+
+    def set_taggable
+      @taggable_type = params[:taggable_type]
+      @taggable_id = params[:taggable_id]
+
+      @taggable = case @taggable_type
+      when "route"
+        Route.find(@taggable_id)
+      when "request"
+        Request.find(@taggable_id)
+      when "query"
+        Query.find(@taggable_id)
+      else
+        head :not_found
+      end
+    end
+  end
+end

data/app/helpers/rails_pulse/application_helper.rb

@@ -7,6 +7,8 @@ module RailsPulse
     include FormattingHelper
     include StatusHelper
     include TableHelper
+    include FormHelper
+    include TagsHelper
 
     # Replacement for lucide_icon helper that works with pre-compiled assets
     # Outputs a custom element that will be hydrated by Stimulus

data/app/helpers/rails_pulse/form_helper.rb

@@ -0,0 +1,75 @@
+module RailsPulse
+  module FormHelper
+    # Renders a time range selector that can switch between preset ranges and a custom datetime picker
+    #
+    # @param form [ActionView::Helpers::FormBuilder] The form builder instance
+    # @param time_range_options [Array] Array of [label, value] pairs for the select options
+    # @param selected_time_range [Symbol, String] Currently selected time range
+    # @param mode [Symbol] :preset (default) for preset time ranges, :recent_custom for Recent/Custom toggle
+    # @return [String] HTML for the time range selector
+    def time_range_selector(form, time_range_options:, selected_time_range:, mode: :preset)
+      global_filters = session_global_filters
+      has_global_date_range = global_filters["start_time"].present? && global_filters["end_time"].present?
+      global_date_range = has_global_date_range ? "#{global_filters["start_time"]} to #{global_filters["end_time"]}" : ""
+      show_custom_picker = selected_time_range.to_sym == :custom
+      custom_date_value = params.dig(:q, :custom_date_range) || (show_custom_picker && has_global_date_range ? global_date_range : "")
+
+      content_tag(:div, class: "time-range-selector", data: { mode: mode }) do
+        concat time_range_select_wrapper(form, time_range_options, selected_time_range, mode)
+        concat time_range_picker_wrapper(form, custom_date_value)
+      end
+    end
+
+    private
+
+    def time_range_select_wrapper(form, time_range_options, selected_time_range, mode)
+      content_tag(:div, data: { rails_pulse__custom_range_target: "selectWrapper" }, style: "min-width: 150px;") do
+        form.select :period_start_range,
+          time_range_options,
+          { selected: selected_time_range },
+          {
+            class: "input",
+            data: {
+              action: "change->rails-pulse--custom-range#handleChange",
+              mode: mode
+            }
+          }
+      end
+    end
+
+    def time_range_picker_wrapper(form, custom_date_value)
+      content_tag(:div,
+        data: { rails_pulse__custom_range_target: "pickerWrapper" },
+        style: "display: none; position: relative; min-width: 360px;"
+      ) do
+        concat time_range_picker_input(form, custom_date_value)
+        concat time_range_close_button
+      end
+    end
+
+    def time_range_picker_input(form, custom_date_value)
+      form.text_field :custom_date_range,
+        value: custom_date_value,
+        placeholder: "Pick date range",
+        class: "input",
+        style: "padding-inline-end: 2.5rem;",
+        data: {
+          controller: "rails-pulse--datepicker",
+          rails_pulse__datepicker_mode_value: "range",
+          rails_pulse__datepicker_show_months_value: 2,
+          rails_pulse__datepicker_type_value: "datetime"
+        }
+    end
+
+    def time_range_close_button
+      button_tag(
+        rails_pulse_icon("x", width: "18"),
+        type: "button",
+        class: "btn btn--borderless",
+        style: "position: absolute; inset-inline-end: 0; inset-block-start: 0; inset-block-end: 0; padding: 0.5rem; background: transparent; border: none;",
+        data: { action: "click->rails-pulse--custom-range#showSelect" },
+        aria: { label: "Close custom range" }
+      )
+    end
+  end
+end

data/app/helpers/rails_pulse/tags_helper.rb

@@ -0,0 +1,29 @@
+module RailsPulse
+  module TagsHelper
+    # Display tags as badge elements
+    # Accepts:
+    # - Taggable objects (with tag_list method)
+    # - Raw JSON strings from aggregated queries
+    # - Arrays of tags
+    def display_tag_badges(tags)
+      tag_array = case tags
+      when String
+        # Parse JSON string from database
+        begin
+          JSON.parse(tags)
+        rescue JSON::ParserError
+          []
+        end
+      when Array
+        tags
+      else
+        # Handle Taggable objects
+        tags.respond_to?(:tag_list) ? tags.tag_list : []
+      end
+
+      return content_tag(:span, "-", class: "text-subtle") if tag_array.empty?
+
+      safe_join(tag_array.map { |tag| content_tag(:div, tag, class: "badge") }, " ")
+    end
+  end
+end

data/app/javascript/rails_pulse/application.js

@@ -5,6 +5,7 @@ import { Application } from "@hotwired/stimulus";
 
 // CSS Zero Controllers
 import ContextMenuController from "./controllers/context_menu_controller";
+import DatePickerController from "./controllers/datepicker_controller";
 import DialogController from "./controllers/dialog_controller";
 import MenuController from "./controllers/menu_controller";
 import PopoverController from "./controllers/popover_controller";
@@ -19,6 +20,8 @@ import IconController from "./controllers/icon_controller";
 import ExpandableRowsController from "./controllers/expandable_rows_controller";
 import CollapsibleController from "./controllers/collapsible_controller";
 import TableSortController from "./controllers/table_sort_controller";
+import GlobalFiltersController from "./controllers/global_filters_controller";
+import CustomRangeController from "./controllers/custom_range_controller";
 
 const application = Application.start();
 
@@ -33,6 +36,7 @@ window.echarts = echarts;
 window.Turbo = Turbo;
 
 application.register("rails-pulse--context-menu", ContextMenuController);
+application.register("rails-pulse--datepicker", DatePickerController);
 application.register("rails-pulse--dialog", DialogController);
 application.register("rails-pulse--menu", MenuController);
 application.register("rails-pulse--popover", PopoverController);
@@ -46,6 +50,8 @@ application.register("rails-pulse--icon", IconController);
 application.register("rails-pulse--expandable-rows", ExpandableRowsController);
 application.register("rails-pulse--collapsible", CollapsibleController);
 application.register("rails-pulse--table-sort", TableSortController);
+application.register("rails-pulse--global-filters", GlobalFiltersController);
+application.register("rails-pulse--custom-range", CustomRangeController);
 
 // Ensure Turbo Frames are loaded after page load
 document.addEventListener('DOMContentLoaded', () => {