Fail gracefully on server initialization error

Author: vinistock

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -18,7 +18,11 @@ def client
       end
 
       sig { override.params(message_queue: Thread::Queue).void }
-      def activate(message_queue); end
+      def activate(message_queue)
+        # Eagerly initialize the client in a thread. This allows the indexing from the Ruby LSP to continue running even
+        # while we boot large Rails applications in the background
+        Thread.new { client }
+      end
 
       sig { override.void }
       def deactivate

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -14,16 +14,28 @@ class << self
         def create_client
           new
         rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
-          warn("Ruby LSP Rails failed to initialize server: #{e.message}")
+          warn("Ruby LSP Rails failed to initialize server: #{e.message}\n#{e.backtrace&.join("\n")}")
           warn("Server dependent features will not be available")
           NullClient.new
         end
       end
 
+      class InitializationError < StandardError; end
+      class IncompleteMessageError < StandardError; end
+
       extend T::Sig
 
       sig { void }
       def initialize
+        # Spring needs a Process session ID. It uses this ID to "attach" itself to the parent process, so that when the
+        # parent ends, the spring process ends as well. If this is not set, Spring will throw an error while trying to
+        # set its own session ID
+        begin
+          Process.setsid
+        rescue Errno::EPERM
+          # If we can't set the session ID, continue
+        end
+
         stdin, stdout, stderr, wait_thread = Open3.popen3(
           "bin/rails",
           "runner",
@@ -36,11 +48,18 @@ def initialize
         @wait_thread = T.let(wait_thread, Process::Waiter)
         @stdin.binmode # for Windows compatibility
         @stdout.binmode # for Windows compatibility
+
+        read_response
+      rescue Errno::EPIPE, IncompleteMessageError
+        raise InitializationError, @stderr.read
       end
 
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def model(name)
         make_request("model", name: name)
+      rescue IncompleteMessageError
+        warn("Ruby LSP Rails failed to get model information: #{@stderr.read}")
+        nil
       end
 
       sig { void }
@@ -82,8 +101,9 @@ def send_message(request, params = nil)
       sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def read_response
         headers = @stdout.gets("\r\n\r\n")
-        raw_response = @stdout.read(T.must(headers)[/Content-Length: (\d+)/i, 1].to_i)
+        raise IncompleteMessageError unless headers
 
+        raw_response = @stdout.read(headers[/Content-Length: (\d+)/i, 1].to_i)
         response = JSON.parse(T.must(raw_response), symbolize_names: true)
 
         if response[:error]

lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -29,6 +29,53 @@ class Server
 
       extend T::Sig
 
+      sig { void }
+      def initialize
+        $stdin.sync = true
+        $stdout.sync = true
+        @running = T.let(true, T::Boolean)
+      end
+
+      sig { void }
+      def start
+        initialize_result = { result: { message: "ok" } }.to_json
+        $stdout.write("Content-Length: #{initialize_result.length}\r\n\r\n#{initialize_result}")
+
+        while @running
+          headers = $stdin.gets("\r\n\r\n")
+          json = $stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i)
+
+          request = JSON.parse(json, symbolize_names: true)
+          response = execute(request.fetch(:method), request[:params])
+          next if response == VOID
+
+          json_response = response.to_json
+          $stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
+        end
+      end
+
+      private
+
+      sig do
+        params(
+          request: String,
+          params: T::Hash[Symbol, T.untyped],
+        ).returns(T.any(Object, T::Hash[Symbol, T.untyped]))
+      end
+      def execute(request, params = {})
+        case request
+        when "shutdown"
+          @running = false
+          VOID
+        when "model"
+          resolve_database_info_from_model(params.fetch(:name))
+        else
+          VOID
+        end
+      rescue => e
+        { error: "#{e.message}\n#{e.backtrace&.join("\n")}" }
+      end
+
       sig { params(model_name: String).returns(T::Hash[Symbol, T.untyped]) }
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
@@ -51,41 +98,7 @@ def resolve_database_info_from_model(model_name)
         end
         info
       rescue => e
-        {
-          error: e.message,
-        }
-      end
-
-      sig { void }
-      def start
-        $stdin.sync = true
-        $stdout.sync = true
-
-        running = T.let(true, T::Boolean)
-
-        while running
-          headers = $stdin.gets("\r\n\r\n")
-          request = $stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i)
-
-          json = JSON.parse(request, symbolize_names: true)
-          request_method = json.fetch(:method)
-          params = json[:params]
-
-          response = case request_method
-          when "shutdown"
-            running = false
-            VOID
-          when "model"
-            resolve_database_info_from_model(params.fetch(:name))
-          else
-            VOID
-          end
-
-          next if response == VOID
-
-          json_response = response.to_json
-          $stdout.write("Content-Length: #{json_response.length}\r\n\r\n#{json_response}")
-        end
+        { error: e.message }
       end
     end
   end

test/ruby_lsp_rails/server_test.rb

@@ -10,24 +10,24 @@ class ServerTest < ActiveSupport::TestCase
   end
 
   test "returns nil if model doesn't exist" do
-    response = @server.resolve_database_info_from_model("Foo")
+    response = @server.send(:resolve_database_info_from_model, "Foo")
     assert_nil(response.fetch(:result))
   end
 
   test "returns nil if class is not a model" do
-    response = @server.resolve_database_info_from_model("Time")
+    response = @server.send(:resolve_database_info_from_model, "Time")
     assert_nil(response.fetch(:result))
   end
 
   test "returns nil if class is an abstract model" do
-    response = @server.resolve_database_info_from_model("ApplicationRecord")
+    response = @server.send(:resolve_database_info_from_model, "ApplicationRecord")
     assert_nil(response.fetch(:result))
   end
 
   test "handles older Rails version which don't have `schema_dump_path`" do
     ActiveRecord::Tasks::DatabaseTasks.send(:alias_method, :old_schema_dump_path, :schema_dump_path)
     ActiveRecord::Tasks::DatabaseTasks.undef_method(:schema_dump_path)
-    response = @server.resolve_database_info_from_model("User")
+    response = @server.send(:resolve_database_info_from_model, "User")
     assert_nil(response.fetch(:result)[:schema_file])
   ensure
     ActiveRecord::Tasks::DatabaseTasks.send(:alias_method, :schema_dump_path, :old_schema_dump_path)