prebake 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5526a96f538034fd54828e704413a28c12d7ee26e6b7489bc93a8366615bab9d
-  data.tar.gz: 6f5c1ad1a6ae983ca8a0d7ddfbe13f633da314eefa5609716cb1c4a4569a804e
+  metadata.gz: 5016083674e522c23d95fa0526df6b35f159e529b0d3116fc24daf70e1c52df9
+  data.tar.gz: 7a32973b781cb342998d150c5fe75b944c4865055df2f168c2bebeb48fa1450c
 SHA512:
-  metadata.gz: 616f1f3d581285820312d232bb64465cd179161f8c4b846db4d9c8904acfb08b92137651ceecb932eb83bee811ebdd6cf553dc764168bb2597b6916e8435c896
-  data.tar.gz: 4583a32a07fd38a498e3976a335fc106cae77e951c3a858d0a8d2df97af0c79fe2a08d397f7310779c551221412889d8903fa59f91fe566b629c2b5f40a87b95
+  metadata.gz: b9ea7f985f4ca767edaca8598a79023e0ec9c0fe1ea9e5219a368ce4d44e4d0ef8ccb8bf8a57434fce514afc9e80694a4a72c3e2335d54ba37d2857a8d43476d
+  data.tar.gz: 05adfe955164c50037842cd380504e938df4618160de34c9fee7e7e25e225226eefb44a4a9fc6a2181f41702e23ff2ed00686bffaee20643de811cde9d98922a

data/lib/prebake/async_publisher.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require_relative "platform_gem_builder"
 require_relative "cache_key"
 require_relative "platform"
+require_relative "elf_inspector"
 require_relative "logger"
 
 module Prebake
@@ -65,6 +66,15 @@ module Prebake
       gem_path = builder.build
       checksum = builder.checksum
 
+      if (max = Prebake.max_glibc)
+        required = ElfInspector.required_glibc_for_gem(gem_path)
+        if required && Gem::Version.new(required) > Gem::Version.new(max)
+          Logger.warn "Skipping push of #{cache_key}: requires glibc #{required} (> PREBAKE_MAX_GLIBC=#{max})"
+          FileUtils.rm_f(gem_path)
+          return nil
+        end
+      end
+
       Logger.debug "Built #{cache_key}"
       [gem_path, cache_key, checksum, backend]
     rescue StandardError => e

data/lib/prebake/elf_inspector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require "tmpdir"
+require "rubygems/package"
+require_relative "logger"
+
+module Prebake
+  module ElfInspector
+    def self.required_glibc_for_gem(gem_path)
+      Dir.mktmpdir("prebake-portability") do |tmpdir|
+        Gem::Package.new(gem_path).extract_files(tmpdir)
+        versions = Dir.glob(File.join(tmpdir, "**/*.{so,bundle,dll}")).filter_map do |binary|
+          next if File.symlink?(binary) || File.size(binary).zero?
+
+          required_glibc(binary)
+        end
+        return nil if versions.empty?
+
+        versions.max_by { |v| Gem::Version.new(v) }
+      end
+    rescue StandardError => e
+      # Malformed gem, missing objdump, or I/O error — treat as unknown, let
+      # downstream extraction catch real corruption.
+      Logger.debug "Portability inspection failed for #{File.basename(gem_path)}: #{e.message}"
+      nil
+    end
+
+    def self.required_glibc(path)
+      return nil unless File.exist?(path)
+
+      output = run_objdump(path)
+      return nil if output.nil? || output.empty?
+
+      parse_glibc_version(output)
+    end
+
+    def self.parse_glibc_version(output)
+      versions = output.scan(/GLIBC_(\d+(?:\.\d+)+)/).flatten
+      return nil if versions.empty?
+
+      versions.max_by { |v| Gem::Version.new(v) }
+    end
+
+    def self.run_objdump(path)
+      out, status = Open3.capture2e("objdump", "-T", path)
+      return nil unless status.success?
+
+      out
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/prebake/ext_builder_patch.rb

@@ -6,6 +6,8 @@ require "digest"
 require_relative "cache_key"
 require_relative "platform"
 require_relative "extractor"
+require_relative "elf_inspector"
+require_relative "glibc"
 require_relative "logger"
 
 module Prebake
@@ -38,6 +40,11 @@ module Prebake
       end
 
       if verify_checksum(cache_key, expected_checksum, cached_gem)
+        unless portable_for_host?(cached_gem)
+          # Binary is valid for other hosts; don't delete from backend.
+          return super
+        end
+
         installed = begin
           install_from_cache(cached_gem)
         rescue StandardError => e
@@ -78,6 +85,18 @@ module Prebake
       end
     end
 
+    def portable_for_host?(gem_path)
+      # Cache key already segregates platforms; glibc check only applies on linux.
+      return true unless Glibc.linux?
+      return true if Prebake.skip_portability_check?
+
+      required = ElfInspector.required_glibc_for_gem(gem_path)
+      return true if Glibc.compatible?(required)
+
+      Logger.warn "Cached #{@spec.name} requires glibc #{required}, host has #{Glibc.detected_version || 'unknown'}; falling back to source build"
+      false
+    end
+
     def install_from_cache(gem_path)
       count = Extractor.install(gem_path, @spec)
 

data/lib/prebake/extension_validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "logger"
+
+module Prebake
+  module ExtensionValidator
+    BINARY_GLOB = "*.{so,bundle,dll}"
+
+    def self.validate_all
+      Bundler.definition.specs.each { |spec| validate(spec) }
+    end
+
+    def self.validate(spec)
+      ext_dir = spec.extension_dir
+      return unless File.exist?(File.join(ext_dir, ".prebake"))
+
+      # Fast path: root-level binaries already present
+      return if Dir.glob(File.join(ext_dir, BINARY_GLOB)).any?
+
+      # Scan known-broken nested patterns
+      nested = Dir.glob(File.join(ext_dir, "extension", "*", "*", BINARY_GLOB))
+      nested.concat(Dir.glob(File.join(ext_dir, "lib", BINARY_GLOB)))
+
+      nested.each do |binary|
+        next if File.symlink?(binary)
+        next if File.size(binary).zero?
+
+        dest = File.join(ext_dir, File.basename(binary))
+        next if File.exist?(dest)
+
+        FileUtils.cp(binary, dest)
+        Logger.info "Validator: copied #{File.basename(binary)} to #{ext_dir}"
+      end
+    end
+  end
+end

data/lib/prebake/extractor.rb

@@ -46,6 +46,9 @@ module Prebake
         end
       end
 
+      # Mark this extension_dir as prebake-managed for post-install validation
+      FileUtils.touch(File.join(spec.extension_dir, ".prebake")) if extracted_count > 0
+
       Logger.info "Installed precompiled #{File.basename(gem_path)} " \
                   "(#{extracted_count} binary files)"
 

data/lib/prebake/glibc.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Prebake
+  module Glibc
+    GNU_LIBC_PATTERN = /GLIBC\s+(\d+(?:\.\d+)+)|GNU libc[^\n]*\s(\d+(?:\.\d+)+)/
+
+    def self.compatible?(required)
+      return true unless linux?
+      return true if required.nil?
+
+      detected = detected_version
+      return false if detected.nil?
+
+      Gem::Version.new(detected) >= Gem::Version.new(required)
+    end
+
+    def self.detected_version
+      return @detected_version if defined?(@detected_version)
+
+      output = run_ldd
+      @detected_version = output ? parse_version(output) : nil
+    end
+
+    def self.parse_version(output)
+      match = output.match(GNU_LIBC_PATTERN)
+      match && (match[1] || match[2])
+    end
+
+    def self.linux?
+      RUBY_PLATFORM.include?("linux")
+    end
+
+    def self.reset!
+      remove_instance_variable(:@detected_version) if defined?(@detected_version)
+    end
+
+    def self.run_ldd
+      out, status = Open3.capture2e("ldd", "--version")
+      return nil unless status.success?
+
+      out
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/prebake/hooks.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "async_publisher"
+require_relative "extension_validator"
 require_relative "logger"
 
 module Prebake
@@ -21,6 +22,8 @@ module Prebake
       end
 
       Bundler::Plugin::API.hook("after-install-all") do |_deps|
+        ExtensionValidator.validate_all
+
         next unless Prebake.push_enabled?
 
         AsyncPublisher.wait_for_completion

data/lib/prebake/logger.rb

@@ -2,10 +2,10 @@
 
 module Prebake
   module Logger
-    LEVELS = { debug: 0, info: 1, warn: 2 }.freeze
+    LEVELS = { debug: 0, info: 1, warn: 2, silent: 3 }.freeze
 
     def self.level
-      @level ||= LEVELS.fetch(ENV.fetch("PREBAKE_LOG_LEVEL", "warn").to_sym, 1)
+      @level ||= LEVELS.fetch(ENV.fetch("PREBAKE_LOG_LEVEL", "silent").to_sym, 3)
     end
 
     def self.debug(msg)

data/lib/prebake.rb

@@ -19,6 +19,14 @@ module Prebake
     enabled? && ENV.fetch("PREBAKE_PUSH_ENABLED", "false") == "true"
   end
 
+  def self.skip_portability_check?
+    ENV.fetch("PREBAKE_SKIP_PORTABILITY_CHECK", "false") == "true"
+  end
+
+  def self.max_glibc
+    ENV.fetch("PREBAKE_MAX_GLIBC", nil)
+  end
+
   def self.backend
     return @backend if defined?(@backend_loaded)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prebake
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.10
 platform: ruby
 authors:
 - Thejus Paul
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-30 00:00:00.000000000 Z
+date: 2026-04-20 00:00:00.000000000 Z
 dependencies: []
 description: Prebake speeds up bundle install by skipping native gem compilation.
   It fetches precompiled binaries for gems like puma, nokogiri, pg, grpc, and bootsnap
@@ -31,8 +31,11 @@ files:
 - lib/prebake/backends/http_client.rb
 - lib/prebake/backends/s3.rb
 - lib/prebake/cache_key.rb
+- lib/prebake/elf_inspector.rb
 - lib/prebake/ext_builder_patch.rb
+- lib/prebake/extension_validator.rb
 - lib/prebake/extractor.rb
+- lib/prebake/glibc.rb
 - lib/prebake/hooks.rb
 - lib/prebake/logger.rb
 - lib/prebake/platform.rb