fix: solve linter issues

Author: Bulletdev

app/channels/application_cable/connection.rb

@@ -52,17 +52,8 @@ def route_by_token_type(payload)
     end
 
     def authenticate_user_connection(payload)
-      user = User.find_by(id: payload[:user_id])
-
-      if user.nil?
-        logger.warn "[ActionCable] User not found for token user_id=#{payload[:user_id]}"
-        reject_unauthorized_connection
-      end
-
-      unless user.organization_id.present?
-        logger.warn "[ActionCable] User #{user.id} has no organization — rejected"
-        reject_unauthorized_connection
-      end
+      user = find_user(payload[:user_id])
+      validate_organization!(user.organization_id, label: "User #{user.id}")
 
       self.current_user   = user
       self.current_player = nil
@@ -71,22 +62,36 @@ def authenticate_user_connection(payload)
     end
 
     def authenticate_player_connection(payload)
-      player = Player.unscoped.find_by(id: payload[:player_id], player_access_enabled: true)
-
-      if player.nil?
-        logger.warn "[ActionCable] Player not found or access disabled: player_id=#{payload[:player_id]}"
-        reject_unauthorized_connection
-      end
-
-      unless player.organization_id.present?
-        logger.warn "[ActionCable] Player #{player.id} has no organization — rejected"
-        reject_unauthorized_connection
-      end
+      player = find_player(payload[:player_id])
+      validate_organization!(player.organization_id, label: "Player #{player.id}")
 
       self.current_user   = nil
       self.current_player = player
       self.current_org_id = player.organization_id
       logger.info "[ActionCable] Connected: player=#{player.id} org=#{player.organization_id}"
     end
+
+    def find_user(user_id)
+      user = User.find_by(id: user_id)
+      return user if user
+
+      logger.warn "[ActionCable] User not found for token user_id=#{user_id}"
+      reject_unauthorized_connection
+    end
+
+    def find_player(player_id)
+      player = Player.unscoped.find_by(id: player_id, player_access_enabled: true)
+      return player if player
+
+      logger.warn "[ActionCable] Player not found or access disabled: player_id=#{player_id}"
+      reject_unauthorized_connection
+    end
+
+    def validate_organization!(org_id, label:)
+      return if org_id.present?
+
+      logger.warn "[ActionCable] #{label} has no organization — rejected"
+      reject_unauthorized_connection
+    end
   end
 end

app/controllers/concerns/authenticatable.rb

@@ -27,25 +27,33 @@ def authenticate_request!
 
   def perform_authentication(token)
     @jwt_payload = JwtService.decode(token)
-
-    # Reject refresh tokens used as access tokens.
-    # Refresh tokens carry type: 'refresh' and must never authenticate a request.
     raise JwtService::TokenInvalidError, 'Invalid token type' unless valid_access_token_type?(@jwt_payload)
 
-    if @jwt_payload[:entity_type] == 'player'
-      authenticate_player_token
-    else
-      authenticate_user_token
-    end
+    dispatch_token_authentication
   rescue JwtService::AuthenticationError => e
     Rails.logger.error("JWT Authentication error: #{e.class} - #{e.message}")
     render_unauthorized(e.message)
   rescue ActiveRecord::RecordNotFound => e
     Rails.logger.error("User not found during authentication: #{e.message}")
     render_unauthorized('User not found')
   rescue StandardError => e
-    Rails.logger.error("Unexpected authentication error: #{e.class} - #{e.message}")
-    Rails.logger.error(e.backtrace.join("\n"))
+    handle_unexpected_auth_error(e)
+  end
+
+  def dispatch_token_authentication
+    # Reject refresh tokens used as access tokens.
+    # Refresh tokens carry type: 'refresh' and must never authenticate a request.
+    # Player access tokens carry entity_type: 'player' AND type: 'access'.
+    if @jwt_payload[:entity_type] == 'player'
+      authenticate_player_token
+    else
+      authenticate_user_token
+    end
+  end
+
+  def handle_unexpected_auth_error(error)
+    Rails.logger.error("Unexpected authentication error: #{error.class} - #{error.message}")
+    Rails.logger.error(error.backtrace.join("\n"))
     render json: { error: { code: 'INTERNAL_ERROR', message: 'An internal error occurred' } },
            status: :internal_server_error
   end

app/controllers/internal/organizations_controller.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Internal
+  # Internal API controller for updating organization tier and subscription data.
+  # Called exclusively by the ProPay payment gateway via a signed internal JWT.
   class OrganizationsController < ActionController::API
     include InternalServiceAuthenticatable
 

app/controllers/status_controller.rb

@@ -6,12 +6,12 @@ class StatusController < ActionController::API
   skip_before_action :verify_authenticity_token, raise: false
 
   COMPONENT_META = {
-    'api'       => { name: 'API',                        description: 'Core REST API services' },
-    'database'  => { name: 'Database',                   description: 'PostgreSQL primary database' },
-    'redis'     => { name: 'Cache & Background Jobs',    description: 'Redis cache and Sidekiq queue processor' },
-    'websocket' => { name: 'Real-time (WebSocket)',       description: 'ActionCable WebSocket connections' },
-    'sidekiq'   => { name: 'Background Jobs (Sidekiq)',  description: 'Async job processing' },
-    'riot_api'  => { name: 'Riot API Integration',       description: 'Riot Games data synchronization' }
+    'api' => { name: 'API', description: 'Core REST API services' },
+    'database' => { name: 'Database', description: 'PostgreSQL primary database' },
+    'redis' => { name: 'Cache & Background Jobs', description: 'Redis cache and Sidekiq queue processor' },
+    'websocket' => { name: 'Real-time (WebSocket)', description: 'ActionCable WebSocket connections' },
+    'sidekiq' => { name: 'Background Jobs (Sidekiq)', description: 'Async job processing' },
+    'riot_api' => { name: 'Riot API Integration', description: 'Riot Games data synchronization' }
   }.freeze
 
   def index
@@ -22,19 +22,19 @@ def index
       indicator, description = overall_status(components)
 
       {
-        status:         { indicator: indicator, description: description },
-        components:     components,
-        incidents:      incidents,
+        status: { indicator: indicator, description: description },
+        components: components,
+        incidents: incidents,
         uptime_history: uptime
       }
     end
 
     render json: cached.merge(
       page: {
-        id:         'prostaff',
-        name:       'ProStaff',
-        url:        'https://status.prostaff.gg',
-        time_zone:  'UTC',
+        id: 'prostaff',
+        name: 'ProStaff',
+        url: 'https://status.prostaff.gg',
+        time_zone: 'UTC',
         updated_at: Time.current.iso8601
       }
     ), status: :ok
@@ -57,13 +57,13 @@ def build_component_statuses
   def build_component_from_snapshot(component, snapshot)
     meta = COMPONENT_META[component]
     {
-      id:               component,
-      name:             meta[:name],
-      status:           snapshot.status,
-      description:      meta[:description],
+      id: component,
+      name: meta[:name],
+      status: snapshot.status,
+      description: meta[:description],
       response_time_ms: snapshot.response_time_ms,
-      last_checked_at:  snapshot.checked_at.iso8601,
-      updated_at:       snapshot.updated_at.iso8601
+      last_checked_at: snapshot.checked_at.iso8601,
+      updated_at: snapshot.updated_at.iso8601
     }
   end
 
@@ -72,13 +72,13 @@ def build_component_live(component)
     result = live_check(component)
 
     {
-      id:               component,
-      name:             meta[:name],
-      status:           result[:status],
-      description:      meta[:description],
+      id: component,
+      name: meta[:name],
+      status: result[:status],
+      description: meta[:description],
       response_time_ms: result[:response_time_ms],
-      last_checked_at:  Time.current.iso8601,
-      updated_at:       Time.current.iso8601
+      last_checked_at: Time.current.iso8601,
+      updated_at: Time.current.iso8601
     }
   end
 
@@ -122,16 +122,16 @@ def build_incidents
 
   def serialize_incident(incident)
     {
-      id:                  incident.id,
-      title:               incident.title,
-      body:                incident.body,
-      severity:            incident.severity,
-      status:              incident.status,
+      id: incident.id,
+      title: incident.title,
+      body: incident.body,
+      severity: incident.severity,
+      status: incident.status,
       affected_components: incident.affected_components,
-      started_at:          incident.started_at.iso8601,
-      resolved_at:         incident.resolved_at&.iso8601,
-      postmortem:          incident.postmortem,
-      updates:             incident.updates.order(created_at: :desc).map do |u|
+      started_at: incident.started_at.iso8601,
+      resolved_at: incident.resolved_at&.iso8601,
+      postmortem: incident.postmortem,
+      updates: incident.updates.order(created_at: :desc).map do |u|
         { id: u.id, status: u.status, body: u.body, created_at: u.created_at.iso8601 }
       end
     }

app/jobs/ml_health_check_job.rb

@@ -42,7 +42,7 @@ def check_service_health
     end
 
     if body['model_loaded'] == false
-      Rails.logger.warn("[MlHealthCheckJob] ML service health: model_loaded=false")
+      Rails.logger.warn('[MlHealthCheckJob] ML service health: model_loaded=false')
     else
       Rails.logger.info("[MlHealthCheckJob] ML service healthy (model_loaded=#{body['model_loaded']})")
     end

app/jobs/rolling_auc_job.rb

@@ -37,8 +37,8 @@ def perform
     auc       = calculate_auc_roc(y_true, y_score)
     mean_prob = y_score.sum / y_score.size
 
-    persist_metrics(auc: auc.round(4), n: logs.size, mean_prob: mean_prob.round(4))
-    emit_alerts(auc: auc, mean_prob: mean_prob, n: logs.size)
+    persist_metrics(auc: auc.round(4), sample_size: logs.size, mean_prob: mean_prob.round(4))
+    emit_alerts(auc: auc, mean_prob: mean_prob, sample_size: logs.size)
 
     record_job_heartbeat
   rescue StandardError => e
@@ -65,16 +65,19 @@ def calculate_auc_roc(y_true, y_score)
 
     sorted = y_true.zip(y_score).sort_by { |_, score| -score }
 
-    tp = 0; fp = 0; prev_fp = 0; auc = 0.0
+    tp = 0
+    fp = 0
+    prev_fp = 0
+    auc = 0.0
 
-    sorted.each do |label, _|
+    sorted.each_key do |label|
       if label == 1
         tp += 1
       else
         # Accumulate trapezoid area for the strip [prev_fp..fp]
         auc += tp.to_f * (fp - prev_fp + 1) / (n_pos * n_neg)
         prev_fp = fp
-        fp      += 1
+        fp += 1
       end
     end
 
@@ -84,21 +87,19 @@ def calculate_auc_roc(y_true, y_score)
     [auc, 1.0].min
   end
 
-  def persist_metrics(auc:, n:, mean_prob:)
+  def persist_metrics(auc:, sample_size:, mean_prob:)
     Sidekiq.redis { |r| r.call('SET', 'ml:metrics:rolling_auc',   auc.to_s) }
-    Sidekiq.redis { |r| r.call('SET', 'ml:metrics:n_predictions', n.to_s) }
+    Sidekiq.redis { |r| r.call('SET', 'ml:metrics:n_predictions', sample_size.to_s) }
     Sidekiq.redis { |r| r.call('SET', 'ml:metrics:mean_win_prob', mean_prob.to_s) }
   rescue StandardError => e
     Rails.logger.warn("[RollingAucJob] Failed to persist metrics to Redis: #{e.message}")
   end
 
-  def emit_alerts(auc:, mean_prob:, n:)
-    if auc < 0.51
-      Rails.logger.warn("[RollingAucJob] ML rolling AUC degraded: #{auc} (n=#{n})")
-    end
+  def emit_alerts(auc:, mean_prob:, sample_size:)
+    Rails.logger.warn("[RollingAucJob] ML rolling AUC degraded: #{auc} (n=#{sample_size})") if auc < 0.51
 
-    if mean_prob < 0.48 || mean_prob > 0.58
-      Rails.logger.warn("[RollingAucJob] ML win prob drift: mean=#{mean_prob} (n=#{n})")
-    end
+    return unless mean_prob < 0.48 || mean_prob > 0.58
+
+    Rails.logger.warn("[RollingAucJob] ML win prob drift: mean=#{mean_prob} (n=#{sample_size})")
   end
 end

app/models/status_snapshot.rb

@@ -16,16 +16,16 @@ class StatusSnapshot < ApplicationRecord
 
   # Returns daily uptime percentage for a component over the last N days.
   def self.uptime_by_day(component:, days: 90)
-    rows    = for_component(component).recent(days).order(checked_at: :asc).pluck(:checked_at, :status)
+    rows = for_component(component).recent(days).order(checked_at: :asc).pluck(:checked_at, :status)
     rows.group_by { |checked_at, _| checked_at.to_date }
         .map { |date, entries| aggregate_day(date, entries) }
   end
 
   # Single-query bulk version: returns { component => [{ date:, uptime_pct:, status: }] }
   def self.bulk_uptime_by_day(days: 90)
     rows = where(checked_at: days.days.ago..Time.current)
-             .order(checked_at: :asc)
-             .pluck(:component, :checked_at, :status)
+           .order(checked_at: :asc)
+           .pluck(:component, :checked_at, :status)
 
     rows
       .group_by(&:first)

app/modules/admin/controllers/ml_metrics_controller.rb

@@ -28,10 +28,10 @@ def index
       rescue StandardError => e
         Rails.logger.warn("[Admin::MlMetricsController] Failed to read metrics: #{e.message}")
         render_success({
-                         rolling_auc:   nil,
+                         rolling_auc: nil,
                          mean_win_prob: nil,
                          n_predictions: nil,
-                         circuit_open:  false
+                         circuit_open: false
                        })
       end
 
@@ -55,10 +55,10 @@ def read_metrics_from_redis
           open_until = r.call('GET', MlServiceClient::CIRCUIT_OPEN_UNTIL_KEY).to_i
 
           {
-            rolling_auc:   auc_raw  ? auc_raw.to_f  : nil,
-            mean_win_prob: mean_raw ? mean_raw.to_f : nil,
-            n_predictions: n_raw    ? n_raw.to_i    : nil,
-            circuit_open:  open_until > Time.now.to_i
+            rolling_auc: auc_raw&.to_f,
+            mean_win_prob: mean_raw&.to_f,
+            n_predictions: n_raw&.to_i,
+            circuit_open: open_until > Time.now.to_i
           }
         end
       end