ragdoll-rails 0.1.8 → 0.1.11

data/app/jobs/ragdoll/process_file_job.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Ragdoll
+  class ProcessFileJob < ApplicationJob
+    queue_as :default
+
+    def perform(file_id, session_id, filename, temp_path)
+      ::Rails.logger.info "🚀 Ragdoll::ProcessFileJob starting: file_id=#{file_id}, session_id=#{session_id}, filename=#{filename}"
+      ::Rails.logger.info "📁 Temp file path: #{temp_path}"
+      ::Rails.logger.info "📊 Temp file exists: #{File.exist?(temp_path)}"
+      ::Rails.logger.info "📏 Temp file size: #{File.exist?(temp_path) ? File.size(temp_path) : 'N/A'} bytes"
+      
+      begin
+        # Verify temp file exists before processing
+        unless File.exist?(temp_path)
+          raise "Temporary file not found: #{temp_path}"
+        end
+        
+        # Broadcast start
+        broadcast_data = {
+          file_id: file_id,
+          filename: filename,
+          status: 'started',
+          progress: 0,
+          message: 'Starting file processing...'
+        }
+        
+        ::Rails.logger.info "📡 Broadcasting start: #{broadcast_data}"
+        begin
+          ActionCable.server.broadcast("ragdoll_file_processing_#{session_id}", broadcast_data)
+          ::Rails.logger.info "✅ ActionCable broadcast sent successfully"
+          
+          # Track job start in monitoring system
+          track_job_progress(session_id, file_id, filename, 0, 'started')
+        rescue => e
+          ::Rails.logger.error "❌ ActionCable broadcast failed: #{e.message}"
+          ::Rails.logger.error e.backtrace.first(3)
+        end
+
+        # Simulate progress updates during processing
+        broadcast_progress(session_id, file_id, filename, 25, 'Reading file...')
+        track_job_progress(session_id, file_id, filename, 25, 'processing')
+        
+        # Use Ragdoll to add document
+        result = ::Ragdoll.add_document(path: temp_path)
+        
+        broadcast_progress(session_id, file_id, filename, 75, 'Generating embeddings...')
+        track_job_progress(session_id, file_id, filename, 75, 'processing')
+        
+        if result[:success] && result[:document_id]
+          document = ::Ragdoll::Document.find(result[:document_id])
+          
+          # Broadcast completion
+          completion_data = {
+            file_id: file_id,
+            filename: filename,
+            status: 'completed',
+            progress: 100,
+            message: 'Processing completed successfully',
+            document_id: document.id
+          }
+          
+          ::Rails.logger.info "🎉 Broadcasting completion: #{completion_data}"
+          begin
+            ActionCable.server.broadcast("ragdoll_file_processing_#{session_id}", completion_data)
+            ::Rails.logger.info "✅ Completion broadcast sent successfully"
+            
+            # Mark job as completed in monitoring system
+            mark_job_completed(session_id, file_id)
+          rescue => e
+            ::Rails.logger.error "❌ Completion broadcast failed: #{e.message}"
+          end
+        else
+          raise "Processing failed: #{result[:error] || 'Unknown error'}"
+        end
+        
+      rescue => e
+        ::Rails.logger.error "💥 Ragdoll::ProcessFileJob error: #{e.message}"
+        ::Rails.logger.error e.backtrace.first(5)
+        
+        # Broadcast error
+        error_data = {
+          file_id: file_id,
+          filename: filename,
+          status: 'error',
+          progress: 0,
+          message: "Error: #{e.message}"
+        }
+        
+        ::Rails.logger.info "📡 Broadcasting error: #{error_data}"
+        begin
+          ActionCable.server.broadcast("ragdoll_file_processing_#{session_id}", error_data)
+          ::Rails.logger.info "✅ Error broadcast sent successfully"
+          
+          # Mark job as failed in monitoring system
+          mark_job_failed(session_id, file_id)
+        rescue => e
+          ::Rails.logger.error "❌ Error broadcast failed: #{e.message}"
+        end
+        
+        # Re-raise the error to mark job as failed
+        raise e
+      ensure
+        # ALWAYS clean up temp file in ensure block
+        if temp_path && File.exist?(temp_path)
+          ::Rails.logger.info "🧹 Cleaning up temp file: #{temp_path}"
+          begin
+            File.delete(temp_path)
+            ::Rails.logger.info "✅ Temp file deleted successfully"
+          rescue => e
+            ::Rails.logger.error "❌ Failed to delete temp file: #{e.message}"
+          end
+        else
+          ::Rails.logger.info "📝 Temp file already cleaned up or doesn't exist: #{temp_path}"
+        end
+      end
+    end
+
+    private
+
+    def broadcast_progress(session_id, file_id, filename, progress, message)
+      broadcast_data = {
+        file_id: file_id,
+        filename: filename,
+        status: 'processing',
+        progress: progress,
+        message: message
+      }
+      
+      ::Rails.logger.info "📡 Broadcasting progress: #{broadcast_data}"
+      begin
+        ActionCable.server.broadcast("ragdoll_file_processing_#{session_id}", broadcast_data)
+        ::Rails.logger.info "✅ Progress broadcast sent successfully"
+      rescue => e
+        ::Rails.logger.error "❌ Progress broadcast failed: #{e.message}"
+      end
+      
+      # Small delay to simulate processing time
+      sleep(0.5)
+    end
+    
+    def track_job_progress(session_id, file_id, filename, progress, status)
+      if defined?(JobFailureMonitorService)
+        JobFailureMonitorService.track_job_progress(session_id, file_id, filename, progress, status)
+      end
+    rescue => e
+      ::Rails.logger.error "❌ Failed to track job progress: #{e.message}"
+    end
+    
+    def mark_job_completed(session_id, file_id)
+      if defined?(JobFailureMonitorService)
+        JobFailureMonitorService.mark_job_completed(session_id, file_id)
+      end
+    rescue => e
+      ::Rails.logger.error "❌ Failed to mark job as completed: #{e.message}"
+    end
+    
+    def mark_job_failed(session_id, file_id)
+      if defined?(JobFailureMonitorService)
+        JobFailureMonitorService.mark_job_failed(session_id, file_id)
+      end
+    rescue => e
+      ::Rails.logger.error "❌ Failed to mark job as failed: #{e.message}"
+    end
+  end
+end

data/app/services/ragdoll/worker_health_service.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ragdoll
+  class WorkerHealthService
+    class << self
+      def check_worker_health
+        {
+          status: 'healthy',
+          workers: worker_status,
+          queues: queue_status,
+          timestamp: Time.current
+        }
+      rescue => e
+        {
+          status: 'error',
+          error: e.message,
+          timestamp: Time.current
+        }
+      end
+
+      def needs_restart?
+        # Check if there are stuck jobs or workers
+        stuck_jobs_count > 5 || !workers_running?
+      rescue
+        false
+      end
+
+      def process_stuck_jobs!(limit = 10)
+        processed = 0
+        
+        # Find jobs that have been processing for too long (e.g., > 1 hour)
+        if defined?(SolidQueue::Job)
+          stuck_jobs = SolidQueue::Job
+            .where(finished_at: nil)
+            .where('created_at < ?', 1.hour.ago)
+            .limit(limit)
+          
+          stuck_jobs.each do |job|
+            job.update(finished_at: Time.current)
+            processed += 1
+          end
+        end
+        
+        processed
+      rescue => e
+        ::Rails.logger.error "Failed to process stuck jobs: #{e.message}"
+        0
+      end
+
+      def restart_workers!
+        # In development, we typically don't restart workers
+        # This would be implemented differently in production
+        ::Rails.logger.info "Worker restart requested (no-op in development)"
+        true
+      rescue => e
+        ::Rails.logger.error "Failed to restart workers: #{e.message}"
+        false
+      end
+
+      private
+
+      def worker_status
+        if defined?(SolidQueue::Worker)
+          {
+            count: SolidQueue::Worker.count,
+            active: SolidQueue::Worker.where('last_heartbeat_at > ?', 5.minutes.ago).count
+          }
+        else
+          { count: 0, active: 0 }
+        end
+      rescue
+        { count: 0, active: 0, error: 'Unable to check worker status' }
+      end
+
+      def queue_status
+        if defined?(SolidQueue::Job)
+          {
+            pending: SolidQueue::Job.where(finished_at: nil).count,
+            completed: SolidQueue::Job.where.not(finished_at: nil).count,
+            failed: defined?(SolidQueue::FailedExecution) ? SolidQueue::FailedExecution.count : 0
+          }
+        else
+          { pending: 0, completed: 0, failed: 0 }
+        end
+      rescue
+        { pending: 0, completed: 0, failed: 0, error: 'Unable to check queue status' }
+      end
+
+      def stuck_jobs_count
+        return 0 unless defined?(SolidQueue::Job)
+        
+        SolidQueue::Job
+          .where(finished_at: nil)
+          .where('created_at < ?', 1.hour.ago)
+          .count
+      rescue
+        0
+      end
+
+      def workers_running?
+        return false unless defined?(SolidQueue::Worker)
+        
+        SolidQueue::Worker
+          .where('last_heartbeat_at > ?', 5.minutes.ago)
+          .exists?
+      rescue
+        true # Assume workers are running if we can't check
+      end
+    end
+  end
+end

data/app/views/layouts/ragdoll/application.html.erb

@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= content_for(:title) || "Ragdoll Dashboard" %></title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="mobile-web-app-capable" content="yes">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    <meta name="csrf-token" content="<%= form_authenticity_token %>">
+
+    <%= yield :head %>
+
+    <%= favicon_link_tag "ragdoll.png", type: "image/png" %>
+    <%= favicon_link_tag "ragdoll.png", rel: "apple-touch-icon" %>
+    <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+    <%= stylesheet_link_tag "ragdoll/bulk_upload_status", "data-turbo-track": "reload" %>
+    
+    <!-- Bootstrap CSS from CDN -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    
+    <!-- Rails UJS for handling method: :delete and data-confirm -->
+    <script src="https://cdn.jsdelivr.net/npm/@rails/ujs@7.0.0/lib/assets/compiled/rails-ujs.js"></script>
+    
+    <!-- ActionCable from CDN with fallback handling -->
+    <script src="https://cdn.jsdelivr.net/gh/rails/rails@7-1-stable/actioncable/app/assets/javascripts/action_cable.js"></script>
+    
+    <!-- Fallback CSS for when CDN is blocked -->
+    <style>
+      .container { max-width: 1200px; margin: 0 auto; padding: 0 15px; }
+      .row { display: flex; flex-wrap: wrap; margin: 0 -15px; }
+      .col-md-8 { flex: 0 0 66.666667%; max-width: 66.666667%; padding: 0 15px; }
+      .col-md-4 { flex: 0 0 33.333333%; max-width: 33.333333%; padding: 0 15px; }
+      .col-12 { flex: 0 0 100%; max-width: 100%; padding: 0 15px; }
+      .card { border: 1px solid #dee2e6; border-radius: 0.375rem; margin-bottom: 1rem; }
+      .card-header { padding: 0.75rem 1.25rem; background-color: #f8f9fa; border-bottom: 1px solid #dee2e6; }
+      .card-body { padding: 1.25rem; }
+      .btn { display: inline-block; padding: 0.375rem 0.75rem; font-size: 1rem; line-height: 1.5; border-radius: 0.375rem; border: 1px solid; text-decoration: none; cursor: pointer; }
+      .btn-primary { color: #fff; background-color: #007bff; border-color: #007bff; }
+      .navbar { padding: 0.5rem 0; background-color: #007bff !important; }
+      .navbar-brand { color: #fff !important; text-decoration: none; font-weight: bold; }
+      .nav-link { color: #fff !important; text-decoration: none; padding: 0.5rem 1rem; }
+      .alert { padding: 0.75rem 1.25rem; margin-bottom: 1rem; border: 1px solid; border-radius: 0.375rem; }
+      .alert-success { color: #155724; background-color: #d4edda; border-color: #c3e6cb; }
+      .alert-danger { color: #721c24; background-color: #f8d7da; border-color: #f5c6cb; }
+      .alert-info { color: #0c5460; background-color: #d1ecf1; border-color: #bee5eb; }
+    </style>
+  </head>
+
+  <body>
+    <nav class="navbar navbar-expand-lg navbar-dark bg-primary">
+      <div class="container">
+        <%= link_to "Ragdoll Dashboard", ragdoll.root_path, class: "navbar-brand" %>
+        
+        <div class="navbar-nav ms-auto">
+          <%= link_to "Dashboard", ragdoll.dashboard_index_path, class: "nav-link" %>
+          <%= link_to "Documents", ragdoll.documents_path, class: "nav-link" %>
+          <%= link_to "Jobs", ragdoll.jobs_path, class: "nav-link" %>
+          <%= link_to "Search", ragdoll.search_index_path, class: "nav-link" %>
+          <%= link_to "Analytics", ragdoll.analytics_path, class: "nav-link" %>
+          <%= link_to "Back to Demo", main_app.root_path, class: "nav-link" %>
+        </div>
+      </div>
+    </nav>
+
+    <% if flash.any? %>
+      <div class="container mt-3">
+        <% flash.each do |type, message| %>
+          <div class="alert alert-<%= type == 'notice' ? 'success' : type == 'alert' ? 'danger' : 'info' %> alert-dismissible fade show" role="alert">
+            <%= message %>
+            <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
+          </div>
+        <% end %>
+      </div>
+    <% end %>
+
+    <main>
+      <%= yield %>
+    </main>
+
+    <!-- JavaScript with fallback support -->
+    <script>
+      // Check if CDN resources loaded, provide fallbacks if not
+      console.log('🔧 Checking JavaScript dependencies...');
+      
+      // ActionCable fallback and App global setup
+      window.App = window.App || {};
+      
+      if (typeof ActionCable === 'undefined') {
+        console.warn('ActionCable not loaded from CDN, using minimal fallback');
+        window.ActionCable = {
+          createConsumer: function(url) {
+            console.log('ActionCable fallback: WebSocket functionality disabled');
+            return {
+              subscriptions: {
+                create: function(channel, callbacks) {
+                  console.log('ActionCable fallback: Channel subscription disabled', channel);
+                  if (callbacks && callbacks.connected) {
+                    setTimeout(() => callbacks.connected(), 100);
+                  }
+                  return {
+                    unsubscribe: function() { console.log('ActionCable fallback: Unsubscribe'); }
+                  };
+                }
+              },
+              disconnect: function() { console.log('ActionCable fallback: Disconnect'); }
+            };
+          }
+        };
+      } else {
+        console.log('✅ ActionCable loaded from CDN');
+      }
+      
+      // Ensure App.cable is available regardless of loading method
+      if (!window.App) {
+        window.App = {};
+      }
+      
+      if (typeof ActionCable !== 'undefined' && !window.App.cable) {
+        try {
+          window.App.cable = ActionCable.createConsumer('/cable');
+          console.log('✅ App.cable initialized from CDN ActionCable');
+          console.log('✅ App.cable consumer ready:', window.App.cable);
+        } catch (e) {
+          console.error('❌ Failed to initialize App.cable:', e);
+        }
+      } else if (window.App.cable) {
+        console.log('✅ App.cable already initialized');
+      }
+      
+      console.log('🚀 JavaScript dependencies check complete');
+      
+      // Additional CDN loading diagnostics
+      console.log('📊 CDN Resource Status:');
+      console.log('- ActionCable CDN loaded:', typeof ActionCable !== 'undefined');
+      console.log('- Bootstrap CDN loaded:', typeof bootstrap !== 'undefined');
+      console.log('- Chart.js CDN loaded:', typeof Chart !== 'undefined');
+      
+      console.log('🔧 Fallback system status:');
+      console.log('- ActionCable fallback:', window.ActionCable ? 'active' : 'inactive');
+      
+      // Initialize Rails UJS
+      if (typeof Rails !== 'undefined') {
+        Rails.start();
+        console.log('✅ Rails UJS initialized');
+      } else {
+        console.warn('⚠️ Rails UJS not available');
+      }
+    </script>
+    
+    <!-- JavaScript from CDN -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    
+    <%= javascript_importmap_tags %>
+    <%= javascript_include_tag 'ragdoll/application', 'data-turbo-track': 'reload' %>
+    <%= javascript_include_tag 'ragdoll/bulk_upload_status', 'data-turbo-track': 'reload' %>
+    
+    <%= yield :javascript %>
+  </body>
+</html>