Fix Logging.reopen_logs! for ruby 3.4

I think this is probably a bug in ruby 3.4's `IO#reopen`, but it's not a
big deal to explicitly copy over the original IO encodings.

Author: nevans

lib/resque/pool/logging.rb

@@ -36,25 +36,10 @@ def self.reopen_logs!
           end
 
           begin
-            # stdin, stdout, stderr are special.  The following dance should
-            # guarantee there is no window where `fp' is unwritable in MRI
-            # (or any correct Ruby implementation).
-            #
-            # Fwiw, GVL has zero bearing here.  This is tricky because of
-            # the unavoidable existence of stdio FILE * pointers for
-            # std{in,out,err} in all programs which may use the standard C library
-            if fp.fileno <= 2
-              # We do not want to hit fclose(3)->dup(2) window for std{in,out,err}
-              # MRI will use freopen(3) here internally on std{in,out,err}
-              fp.reopen(fp.path, "a")
-            else
-              # We should not need this workaround, Ruby can be fixed:
-              #    http://bugs.ruby-lang.org/issues/9036
-              # MRI will not call call fclose(3) or freopen(3) here
-              # since there's no associated std{in,out,err} FILE * pointer
-              # This should atomically use dup3(2) (or dup2(2)) syscall
-              File.open(fp.path, "a") { |tmpfp| fp.reopen(tmpfp) }
-            end
+            fp.reopen(fp.path,
+                      mode: "a",
+                      external_encoding: fp.external_encoding,
+                      internal_encoding: fp.internal_encoding)
 
             fp.sync = true
             fp.flush # IO#sync=true may not implicitly flush

spec/logging_spec.rb

@@ -4,7 +4,6 @@
 describe Resque::Pool::Logging do
 
   let(:expect_flags) { File::WRONLY | File::APPEND }
-  
 
   # Don't pollute the log output
   before(:all) { $skip_logging = true }
@@ -47,9 +46,8 @@
       expect(File.exist?(tmp_path)).to be_truthy
       expect(@before).to_not eq(File.stat(tmp_path).inspect)
       expect(@fp.stat.inspect).to eq(File.stat(tmp_path).inspect)
-      pending("ruby 3.4 reopen resets the encoding to nil!") if "3.4.0" <= RUBY_VERSION
-      expect(@ext).to eq((@fp.external_encoding rescue nil))
-      expect(@int).to eq((@fp.internal_encoding rescue nil))
+      expect((@fp.external_encoding rescue nil)).to eq(@ext)
+      expect((@fp.internal_encoding rescue nil)).to eq(@int)
       expect(expect_flags).to eq((expect_flags & @fp.fcntl(Fcntl::F_GETFL)))
       expect(@fp.sync).to be_truthy
 
@@ -71,7 +69,7 @@
       Encoding.list.each do |encoding|
         File.open(@tmp_path, "a:#{encoding.to_s}") do |fp|
           fp.sync = true
-          expect(encoding).to eq(fp.external_encoding)
+          expect(fp.external_encoding).to eq(encoding)
           expect(fp.internal_encoding).to be_nil
           File.unlink(@tmp_path)
           expect(File.exist?(@tmp_path)).to be_falsey
@@ -80,8 +78,7 @@
           expect(@tmp_path).to eq(fp.path)
           expect(File.exist?(@tmp_path)).to be_truthy
           expect(fp.stat.inspect).to eq(File.stat(@tmp_path).inspect)
-          pending("ruby 3.4 reopen resets the encoding to nil!") if "3.4.0" <= RUBY_VERSION
-          expect(encoding).to eq(fp.external_encoding)
+          expect(fp.external_encoding).to eq(encoding)
           expect(fp.internal_encoding).to be_nil
           expect(expect_flags).to eq((expect_flags & fp.fcntl(Fcntl::F_GETFL)))
           expect(fp.sync).to be_truthy
@@ -96,7 +93,7 @@
           next if ext == int
           File.open(@tmp_path, "a:#{ext.to_s}:#{int.to_s}") do |fp|
             fp.sync = true
-            expect(ext).to eq(fp.external_encoding)
+            expect(fp.external_encoding).to eq(ext)
 
             if ext != Encoding::BINARY
               expect(int).to eq(fp.internal_encoding)
@@ -109,11 +106,10 @@
             expect(@tmp_path).to eq(fp.path)
             expect(File.exist?(@tmp_path)).to be_truthy
             expect(fp.stat.inspect).to eq(File.stat(@tmp_path).inspect)
-            pending("ruby 3.4 reopen resets the encoding to nil!") if "3.4.0" <= RUBY_VERSION
-            expect(ext).to eq(fp.external_encoding)
+            expect(fp.external_encoding).to eq(ext)
 
             if ext != Encoding::BINARY
-              expect(int).to eq(fp.internal_encoding)
+              expect(fp.internal_encoding).to eq(int)
             end
 
             expect(expect_flags).to eq((expect_flags & fp.fcntl(Fcntl::F_GETFL)))