rails_pulse 0.1.4 → 0.2.2

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,48 @@ module RailsPulse
       end
     end
 
+    def set_global_filters
+      if params[:clear] == "true"
+        session.delete(:global_filters)
+      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 +115,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/queries_controller.rb

@@ -1,6 +1,7 @@
 module RailsPulse
   class QueriesController < ApplicationController
     include ChartTableConcern
+    include TagFilterConcern
 
     before_action :set_query, only: [ :show, :analyze ]
 
@@ -114,13 +115,15 @@ 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
         ).to_table
       end
     end

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
 
@@ -55,11 +63,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 +97,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
 
@@ -86,7 +87,7 @@ 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
-        base_query = @ransack_query.result
+        base_query = apply_tag_filters(@ransack_query.result)
           .joins(<<~SQL)
             INNER JOIN rails_pulse_summaries ON
               rails_pulse_summaries.summarizable_id = rails_pulse_requests.route_id AND
@@ -108,7 +109,8 @@ module RailsPulse
           ransack_query: @ransack_query,
           period_type: period_type,
           start_time: @start_time,
-          params: params
+          params: params,
+          disabled_tags: session_disabled_tags
         ).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', () => {

data/app/javascript/rails_pulse/controllers/custom_range_controller.js

@@ -0,0 +1,115 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["selectWrapper", "pickerWrapper"]
+
+  connect() {
+    const selectElement = this.selectWrapperTarget.querySelector('select')
+    if (!selectElement) return
+
+    // Check if we're in recent_custom mode
+    const mode = selectElement.dataset.mode
+
+    if (mode === 'recent_custom') {
+      // In recent_custom mode, "recent" shows no picker, "custom" shows picker
+      if (selectElement.value === "custom") {
+        this.showPicker()
+        this.initializeDatePicker()
+      }
+    } else {
+      // In preset mode, "custom" shows picker
+      if (selectElement.value === "custom") {
+        this.showPicker()
+        this.initializeDatePicker()
+      }
+    }
+  }
+
+  // When time range is selected from dropdown
+  handleChange(event) {
+    const mode = event.target.dataset.mode
+
+    if (mode === 'recent_custom') {
+      // In recent_custom mode
+      if (event.target.value === "custom") {
+        this.showPicker()
+        this.openDatePicker()
+      } else {
+        // "recent" is selected - hide picker
+        this.pickerWrapperTarget.style.display = "none"
+        this.selectWrapperTarget.style.display = "block"
+      }
+    } else {
+      // In preset mode
+      if (event.target.value === "custom") {
+        this.showPicker()
+        this.openDatePicker()
+      }
+    }
+  }
+
+  // Show picker, hide select
+  showPicker() {
+    this.selectWrapperTarget.style.display = "none"
+    this.pickerWrapperTarget.style.display = "flex"
+  }
+
+  // Open the flatpickr calendar
+  openDatePicker() {
+    // Wait a bit for the DOM to update and flatpickr to initialize
+    setTimeout(() => {
+      // Find the original hidden input that has the datepicker controller
+      const hiddenInput = this.pickerWrapperTarget.querySelector('input[name*="custom_date_range"]')
+      if (!hiddenInput) return
+
+      // Get the datepicker controller from the hidden input
+      const datepickerController = this.application.getControllerForElementAndIdentifier(
+        hiddenInput,
+        'rails-pulse--datepicker'
+      )
+
+      if (datepickerController && datepickerController.flatpickr) {
+        datepickerController.flatpickr.open()
+      }
+    }, 50)
+  }
+
+  // Show select, hide picker
+  showSelect() {
+    this.pickerWrapperTarget.style.display = "none"
+    this.selectWrapperTarget.style.display = "block"
+
+    // Reset select to default value based on mode
+    const selectElement = this.selectWrapperTarget.querySelector('select')
+    if (selectElement) {
+      const mode = selectElement.dataset.mode
+      if (mode === 'recent_custom') {
+        selectElement.value = "recent"
+      } else {
+        selectElement.value = "last_day"
+      }
+    }
+  }
+
+  // Initialize flatpickr with existing date value
+  initializeDatePicker() {
+    const dateInput = this.pickerWrapperTarget.querySelector('input[type="text"]')
+    if (!dateInput || !dateInput.value) return
+
+    // Get the datepicker controller
+    const datepickerController = this.application.getControllerForElementAndIdentifier(
+      dateInput,
+      'rails-pulse--datepicker'
+    )
+
+    if (datepickerController && datepickerController.flatpickr) {
+      const value = dateInput.value
+      // Parse the "start to end" format
+      if (value.includes(' to ')) {
+        const [start, end] = value.split(' to ').map(d => d.trim())
+        // Set the dates in flatpickr
+        datepickerController.flatpickr.setDate([start, end], false)
+      }
+    }
+  }
+}

data/app/javascript/rails_pulse/controllers/datepicker_controller.js

@@ -0,0 +1,48 @@
+import { Controller } from "@hotwired/stimulus"
+import flatpickr from "flatpickr"
+
+export default class extends Controller {
+  static targets = [ "details" ]
+  static values  = {
+    type: String, disable: Array,
+    mode: { type: String, default: "single" },
+    showMonths: { type: Number, default: 1 },
+    dateFormat: { type: String, default: "F d, Y" },
+    dateTimeFormat: { type: String, default: "M d, Y h:i K" }
+  }
+
+  connect() {
+    if (this.typeValue == "time") {
+      this.flatpickr = flatpickr(this.element, this.#timeOptions)
+    } else if (this.typeValue == "datetime") {
+      this.flatpickr = flatpickr(this.element, this.#dateTimeOptions)
+    } else {
+      this.flatpickr = flatpickr(this.element, this.#basicOptions)
+    }
+  }
+
+  disconnect() {
+    this.flatpickr.destroy()
+  }
+
+  get #timeOptions() {
+    return { dateFormat: "H:i", enableTime: true, noCalendar: true }
+  }
+
+  get #dateTimeOptions() {
+    return { ...this.#baseOptions, altFormat: this.dateTimeFormatValue, dateFormat: "Y-m-d H:i", enableTime: true }
+  }
+
+  get #basicOptions() {
+    return { ...this.#baseOptions, altFormat: this.dateFormatValue, dateFormat: "Y-m-d" }
+  }
+
+  get #baseOptions() {
+    return {
+      altInput: true,
+      disable: this.disableValue,
+      mode: this.modeValue,
+      showMonths: this.showMonthsValue
+    }
+  }
+}