Upgraded to rails 8.0.2, moved from dalli to solid cache, moved from delayed_job to solid queue, and add solid cable. deploy/rails-dev-run.sh no longer needs to chmod. Fixed finished_at callback for matches. Migrated from Devise to built in rails auth. Added view tests for the bracket page testing that all bout numbers render for all matches in each bracket type.

config/initializers/sqlite_config.rb

@@ -0,0 +1,79 @@
+# Configure SQLite for better concurrency handling
+# This applies only in development mode with SQLite
+
+Rails.application.config.after_initialize do
+  if Rails.env.development? && ActiveRecord::Base.connection.adapter_name == "SQLite"
+    connection = ActiveRecord::Base.connection
+    
+    # 1. Configure SQLite behavior for better concurrency
+    # Increase the busy timeout to 30 seconds (in milliseconds)
+    connection.execute("PRAGMA busy_timeout = 30000;")
+    
+    # Set journal mode to WAL for better concurrency
+    connection.execute("PRAGMA journal_mode = WAL;")
+    
+    # Configure synchronous mode for better performance
+    connection.execute("PRAGMA synchronous = NORMAL;")
+    
+    # Temp store in memory for better performance
+    connection.execute("PRAGMA temp_store = MEMORY;")
+    
+    # Use a larger cache size (8MB)
+    connection.execute("PRAGMA cache_size = -8000;")
+    
+    # Set locking mode to NORMAL
+    connection.execute("PRAGMA locking_mode = NORMAL;")
+    
+    # 2. Patch SQLite adapter with retry logic for development only
+    if defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+      module SQLite3RetryLogic
+        MAX_RETRIES = 5
+        RETRY_DELAY = 0.5 # seconds
+        RETRIABLE_EXCEPTIONS = [
+          SQLite3::BusyException, 
+          ActiveRecord::StatementInvalid, 
+          ActiveRecord::StatementTimeout
+        ]
+        
+        def self.included(base)
+          base.class_eval do
+            alias_method :original_execute, :execute
+            alias_method :original_exec_query, :exec_query
+            
+            def execute(*args)
+              with_retries { original_execute(*args) }
+            end
+            
+            def exec_query(*args)
+              with_retries { original_exec_query(*args) }
+            end
+            
+            private
+              def with_retries
+                retry_count = 0
+                begin
+                  yield
+                rescue *RETRIABLE_EXCEPTIONS => e
+                  if e.to_s.include?('database is locked') && retry_count < MAX_RETRIES
+                    retry_count += 1
+                    delay = RETRY_DELAY * retry_count
+                    Rails.logger.warn "SQLite database locked, retry #{retry_count}/#{MAX_RETRIES} after #{delay}s: #{e.message}"
+                    sleep(delay)
+                    retry
+                  else
+                    raise
+                  end
+                end
+              end
+          end
+        end
+      end
+      
+      # Apply the patch only in development
+      ActiveRecord::ConnectionAdapters::SQLite3Adapter.include(SQLite3RetryLogic)
+      Rails.logger.info "SQLite adapter patched with retry logic for database locks"
+    end
+    
+    Rails.logger.info "SQLite configured for improved concurrency in development"
+  end
+end