fixed puma integration

Author: ndbroadbent

.cspell/project-words.txt

@@ -68,3 +68,4 @@ xorshift
 yardoc
 hostnames
 ESRCH
+demodulize

lib/log_struct/integrations/puma.rb

@@ -12,6 +12,7 @@ module Puma
           installed: false,
           boot_emitted: false,
           shutdown_emitted: false,
+          handler_pending_started: false,
           start_info: {
             mode: nil,
             puma_version: nil,
@@ -158,6 +159,7 @@ def state_reset!
           STATE[:boot_emitted] = false
           STATE[:shutdown_emitted] = false
           STATE[:started_emitted] = false
+          STATE[:handler_pending_started] = false
           STATE[:start_info] = {
             mode: nil,
             puma_version: nil,
@@ -223,7 +225,9 @@ def process_line(line)
 
           if (m = l.match(/^\*?\s*Listening on (.+)$/))
             si = T.cast(STATE[:start_info], T::Hash[Symbol, T.untyped])
-            si[:listening] << T.must(m[1])
+            list = T.cast(si[:listening], T::Array[T.untyped])
+            address = T.must(m[1])
+            list << address unless list.include?(address)
             # Emit started when we see the first listening address
             if !STATE[:started_emitted]
               emit_started!
@@ -258,7 +262,7 @@ def process_line(line)
               emit_started!
               STATE[:started_emitted] = true
             end
-            return true
+            return false
           end
 
           if l.start_with?("- Gracefully stopping")
@@ -309,6 +313,7 @@ def emit_started!
             timestamp: Time.now
           )
           LogStruct.info(log)
+          STATE[:handler_pending_started] = false
           # Only use LogStruct; SemanticLogger routes to STDOUT in test
         end
 
@@ -393,43 +398,75 @@ def log(str)
       module RackHandlerPatch
         extend T::Sig
 
-        sig { params(app: T.untyped, options: T.untyped).returns(T.untyped) }
-        def run(app, options)
-          # Emit started once per process
+        sig do
+          params(
+            app: T.untyped,
+            args: T.untyped,
+            block: T.nilable(T.proc.returns(T.untyped))
+          ).returns(T.untyped)
+        end
+        def run(app, *args, &block)
+          rest = args
+          options = T.let({}, T::Hash[T.untyped, T.untyped])
+          rest.each do |value|
+            next unless value.is_a?(Hash)
+            options.merge!(value)
+          end
+
           begin
+            si = T.cast(::LogStruct::Integrations::Puma::STATE[:start_info], T::Hash[Symbol, T.untyped])
+            si[:mode] ||= "single"
+            si[:environment] ||= ((defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil)
+            si[:pid] ||= Process.pid
+            si[:listening] ||= []
             port = T.let(nil, T.untyped)
             host = T.let(nil, T.untyped)
             if options.respond_to?(:[])
               port = options[:Port] || options["Port"] || options[:port] || options["port"]
               host = options[:Host] || options["Host"] || options[:host] || options["host"]
             end
-            addr = if port
+            if port
+              list = T.cast(si[:listening], T::Array[T.untyped])
+              list.clear
               h = (host && host != "0.0.0.0") ? host : "127.0.0.1"
-              ["tcp://#{h}:#{port}"]
+              list << "tcp://#{h}:#{port}"
             end
-            started = ::LogStruct::Log::Puma::Started.new(
-              mode: "single",
-              environment: (defined?(::Rails) && ::Rails.respond_to?(:env)) ? ::Rails.env : nil,
-              process_id: Process.pid,
-              listening_addresses: addr
-            )
-            ::LogStruct.info(started)
+            state = ::LogStruct::Integrations::Puma::STATE
+            state[:handler_pending_started] = true unless state[:started_emitted]
           rescue => e
             ::LogStruct::Integrations::Puma.handle_integration_error(e)
           end
 
           begin
             Kernel.at_exit do
-              shutdown = ::LogStruct::Log::Puma::Shutdown.new(process_id: Process.pid)
-              ::LogStruct.info(shutdown)
+              unless ::LogStruct::Integrations::Puma::STATE[:shutdown_emitted]
+                ::LogStruct::Integrations::Puma.emit_shutdown!("Exiting")
+                ::LogStruct::Integrations::Puma::STATE[:shutdown_emitted] = true
+              end
             rescue => e
               ::LogStruct::Integrations::Puma.handle_integration_error(e)
             end
           rescue => e
             ::LogStruct::Integrations::Puma.handle_integration_error(e)
           end
 
-          super
+          begin
+            result = super(app, **options, &block)
+          ensure
+            state = ::LogStruct::Integrations::Puma::STATE
+            if state[:handler_pending_started] && !state[:started_emitted]
+              begin
+                ::LogStruct::Integrations::Puma.emit_started!
+                state[:started_emitted] = true
+              rescue => e
+                ::LogStruct::Integrations::Puma.handle_integration_error(e)
+              ensure
+                state[:handler_pending_started] = false
+              end
+            end
+          end
+
+          result
         end
       end
 

lib/log_struct/rails_boot_banner_silencer.rb

@@ -20,12 +20,103 @@ def self.install!
 
     sig { void }
     def self.patch!
-      # Do not suppress Rails::Server boot info completely; we rely on
-      # some of those lines for Puma readiness parsing.
+      begin
+        require "rails/command"
+        require "rails/commands/server/server_command"
+      rescue LoadError
+        # Best-effort – if Rails isn't available yet we'll try again later
+        return
+      end
 
-      # Also silence Thor/ServerCommand banner printing used by Rails CLI
-      # Minimal silencer: leave as no-op to avoid Sorbet issues.
-      nil
+      server_command = T.let(nil, T.untyped)
+      # rubocop:disable Sorbet/ConstantsFromStrings
+      begin
+        server_command = ::Object.const_get("Rails::Command::ServerCommand")
+      rescue NameError
+        server_command = nil
+      end
+      # rubocop:enable Sorbet/ConstantsFromStrings
+      return unless server_command
+
+      patch_server_command(server_command)
+    end
+
+    sig { params(server_command: T.untyped).void }
+    def self.patch_server_command(server_command)
+      return if server_command <= ServerCommandSilencer
+
+      server_command.prepend(ServerCommandSilencer)
+    end
+
+    module ServerCommandSilencer
+      extend T::Sig
+
+      sig { params(args: T.untyped, block: T.nilable(T.proc.returns(T.untyped))).returns(T.untyped) }
+      def perform(*args, &block)
+        mark_server_mode!
+        super
+      end
+
+      sig { params(server: T.untyped, url: T.nilable(String)).void }
+      def print_boot_information(server, url)
+        mark_server_mode!
+        consume_boot_banner(server, url)
+      end
+
+      private
+
+      sig { void }
+      def mark_server_mode!
+        ::LogStruct.instance_variable_set(:@server_mode, true)
+      rescue
+        # Ignore – server mode is best-effort
+      end
+
+      sig { params(server: T.untyped, url: T.nilable(String)).void }
+      def consume_boot_banner(server, url)
+        return unless defined?(::LogStruct::Integrations::Puma)
+
+        begin
+          ::LogStruct::Integrations::Puma.emit_boot_if_needed!
+        rescue => e
+          ::LogStruct::Integrations::Puma.handle_integration_error(e)
+        end
+
+        begin
+          model = ::ActiveSupport::Inflector.demodulize(server)
+        rescue
+          model = "Puma"
+        end
+
+        lines = [
+          "=> Booting #{model}",
+          build_rails_banner_line(url),
+          "=> Run `#{lookup_executable} --help` for more startup options"
+        ]
+
+        lines.each do |line|
+          ::LogStruct::Integrations::Puma.process_line(line)
+        rescue => e
+          ::LogStruct::Integrations::Puma.handle_integration_error(e)
+        end
+      end
+
+      sig { params(url: T.nilable(String)).returns(String) }
+      def build_rails_banner_line(url)
+        suffix = url ? " #{url}" : ""
+        "=> Rails #{::Rails.version} application starting in #{::Rails.env}#{suffix}"
+      rescue
+        "=> Rails application starting"
+      end
+
+      sig { returns(String) }
+      def lookup_executable
+        return "rails" unless T.unsafe(self).respond_to?(:executable, true)
+
+        T.cast(T.unsafe(self).send(:executable), String)
+      rescue
+        "rails"
+      end
     end
   end
 end

rails_test_app/create_app.rb

@@ -192,6 +192,27 @@ def copy_template(file, target_path = nil)
     gemfile_content.sub!(/^(\s*gem\s+"rails".*$)/, "\\1\n# Use sqlite3 as the database for Active Record\n gem \"sqlite3\", \">= 2.1\"")
   end
 
+  # Pin Puma version to exercise both legacy and modern releases across the matrix
+  puma_requirement = if @rails_major_minor == "7.0"
+    "~> 6.4"
+  else
+    "~> 7.0"
+  end
+
+  if gemfile_content.match?(/^(\s*# Use the Puma web server.*\n)(\s*gem\s+"puma".*$)/)
+    gemfile_content.gsub!(
+      /(\s*# Use the Puma web server.*\n)\s*gem\s+"puma".*$/,
+      "\\1 gem \"puma\", \"#{puma_requirement}\""
+    )
+  elsif gemfile_content.match?(/^\s*gem\s+"puma"/)
+    gemfile_content.gsub!(/^\s*gem\s+"puma".*$/, "gem \"puma\", \"#{puma_requirement}\"")
+  else
+    gemfile_content.sub!(
+      /^(\s*gem\s+"rails".*$)/,
+      "\\1\n# Use the Puma web server\n gem \"puma\", \"#{puma_requirement}\""
+    )
+  end
+
   # Add LogStruct gem
   logstruct_gem_line = "# LogStruct gem from local path\ngem \"logstruct\", path: \"#{ROOT_DIR}\"\n\n"
   if gemfile_content.include?("logstruct")