prebake 0.2.9 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2c8911f4634bbddf8455aae1f54efc5985f72372a3cd1581fa890da5fc7e543
-  data.tar.gz: 2efa89bd847b4c67eceb11479452267bd68812e503bba51f997317e469cd8b38
+  metadata.gz: 27e9af4988afacc2c07ae6e09eac8aa9efa26d44dc95401cd4f1d52e14993bd6
+  data.tar.gz: 801beefc4a2eed88cda591e6cf0b6abbef13a8f597f185eececeafd49b9e6857
 SHA512:
-  metadata.gz: 73e53914ed4dec0e1a0b5ce3a9be292cd75cf0d8e4c24336ad341b0573f939e46c09f079e2afde4b23ba51fd1127aaa54dae96018546492187417689b5ccdefe
-  data.tar.gz: ed0b096a62e01f40d859033457ed6ed0b9ba8301df0fa90bed67100195687afe33af3e92a52959d8c2bfbbc741dba9be7b3994def8f998a23641fb14eca1d2be
+  metadata.gz: 9911d705b900209619e8051a3d01acb4fdd1337b026f93b577f6b6113cee8ce0a18fa5f88af9316988c7433f01232700731776ff562b8f7d85910cdcd94c802f
+  data.tar.gz: 80a33006c4a8159bb0b5f594b95c9b60f443e0126f3862fc2c526424794bc2acf6ff2c90ad4bbbec88c58ce0a1dba40ff05c7cc48001e9c0568675f53013fc07

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,21 @@ 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
+
+      if !Prebake.libruby_available? && ElfInspector.libruby_needed_for_gem?(gem_path)
+        Logger.warn "Skipping push of #{cache_key}: binary requires libruby.so (dynamic Ruby) but this is a static Ruby build; binary would crash on this platform"
+        FileUtils.rm_f(gem_path)
+        return nil
+      end
+
       Logger.debug "Built #{cache_key}"
       [gem_path, cache_key, checksum, backend]
     rescue StandardError => e

data/lib/prebake/elf_inspector.rb

@@ -0,0 +1,79 @@
+# 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)
+      versions = []
+      each_gem_binary(gem_path) { |binary| v = required_glibc(binary); versions << v if v }
+      versions.empty? ? nil : versions.max_by { |v| Gem::Version.new(v) }
+    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.libruby_needed_for_gem?(gem_path)
+      each_gem_binary(gem_path) { |binary| return true if libruby_needed?(binary) }
+      false
+    rescue StandardError => e
+      Logger.debug "libruby inspection failed for #{File.basename(gem_path)}: #{e.message}"
+      false
+    end
+
+    def self.libruby_needed?(path)
+      needed_libraries(path).any? { |lib| lib.start_with?("libruby") }
+    end
+
+    def self.needed_libraries(path)
+      out, status = Open3.capture2e("objdump", "-p", path)
+      return [] unless status.success?
+
+      out.scan(/NEEDED\s+(\S+)/).flatten
+    rescue Errno::ENOENT
+      []
+    end
+
+    def self.run_objdump(path)
+      out, status = Open3.capture2e("objdump", "-T", path)
+      return nil unless status.success?
+
+      out
+    rescue Errno::ENOENT
+      nil
+    end
+
+    private_class_method def self.each_gem_binary(gem_path)
+      Dir.mktmpdir("prebake-gem") do |tmpdir|
+        Gem::Package.new(gem_path).extract_files(tmpdir)
+        Dir.glob(File.join(tmpdir, "**/*.{so,bundle,dll}")).each do |binary|
+          next if File.symlink?(binary) || File.size(binary).zero?
+
+          yield binary
+        end
+      end
+    end
+  end
+end

data/lib/prebake/ext_builder_patch.rb

@@ -6,6 +6,7 @@ require "digest"
 require_relative "cache_key"
 require_relative "platform"
 require_relative "extractor"
+require_relative "portability_guard"
 require_relative "logger"
 
 module Prebake
@@ -15,6 +16,12 @@ module Prebake
       return super unless Prebake.enabled?
       return super unless Prebake.backend # nil if config failed
 
+      if Prebake.optional_native_extension?(@spec.name) && !Prebake.libruby_available?
+        Logger.warn "#{@spec.name}: native extension skipped (optional gem, libruby.so absent on static Ruby build)"
+        install_without_native_extension
+        return
+      end
+
       platform = Platform.generalized
       cache_key = CacheKey.for(@spec.name, @spec.version.to_s, platform)
 
@@ -38,6 +45,11 @@ module Prebake
       end
 
       if verify_checksum(cache_key, expected_checksum, cached_gem)
+        unless PortabilityGuard.portable_for_host?(cached_gem, spec_name: @spec.name)
+          # 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 +90,10 @@ module Prebake
       end
     end
 
+    def install_without_native_extension
+      mark_build_complete
+    end
+
     def install_from_cache(gem_path)
       count = Extractor.install(gem_path, @spec)
 
@@ -86,9 +102,13 @@ module Prebake
         return false
       end
 
+      mark_build_complete
+      true
+    end
+
+    def mark_build_complete
       FileUtils.mkdir_p(File.dirname(@spec.gem_build_complete_path))
       FileUtils.touch(@spec.gem_build_complete_path)
-      true
     end
   end
 end

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/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/portability_guard.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "elf_inspector"
+require_relative "glibc"
+require_relative "logger"
+
+module Prebake
+  # Host-side portability guards for cached gems: ensures the cached binary
+  # will actually load on this host (glibc version + libruby.so presence).
+  module PortabilityGuard
+    module_function
+
+    def portable_for_host?(gem_path, spec_name:)
+      return true unless Glibc.linux?
+      return true if Prebake.skip_portability_check?
+
+      glibc_ok?(gem_path, spec_name:) && libruby_ok?(gem_path, spec_name:)
+    end
+
+    def glibc_ok?(gem_path, spec_name:)
+      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 libruby_ok?(gem_path, spec_name:)
+      return true if Prebake.libruby_available?
+      return true unless ElfInspector.libruby_needed_for_gem?(gem_path)
+
+      Logger.warn "Cached #{spec_name} requires libruby.so (dynamic Ruby build) " \
+                  "but this host has a static Ruby; falling back to source build"
+      false
+    end
+  end
+end

data/lib/prebake/static_ruby.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Prebake
+  # Detection and configuration for static Ruby builds (e.g. Paketo MRI buildpack),
+  # where libruby.so is absent and native extensions dynamically linked against it
+  # would crash at load time.
+  module StaticRuby
+    # Gems whose native extensions are entirely optional — the gem runs correctly in pure Ruby
+    # mode when the extension can't be loaded. Prebake skips the extension for these gems
+    # instead of installing a broken .so. Extend via PREBAKE_OPTIONAL_NATIVE_EXTENSIONS=gem1,gem2.
+    OPTIONAL_NATIVE_EXTENSIONS_DEFAULT = %w[bootsnap].freeze
+
+    class << self
+      def optional_native_extensions
+        @optional_native_extensions ||= begin
+          extra = ENV.fetch("PREBAKE_OPTIONAL_NATIVE_EXTENSIONS", "")
+                     .split(",").map(&:strip).reject(&:empty?)
+          (OPTIONAL_NATIVE_EXTENSIONS_DEFAULT + extra).uniq
+        end
+      end
+
+      def optional_native_extension?(gem_name)
+        optional_native_extensions.include?(gem_name)
+      end
+
+      def libruby_available?
+        return @libruby_available if defined?(@libruby_available)
+
+        libruby_so = RbConfig::CONFIG["LIBRUBY_SO"]
+        @libruby_available = !libruby_so.nil? && !libruby_so.empty? &&
+                             File.exist?(File.join(RbConfig::CONFIG["libdir"], libruby_so))
+      end
+
+      def reset!
+        remove_instance_variable(:@optional_native_extensions) if defined?(@optional_native_extensions)
+        remove_instance_variable(:@libruby_available) if defined?(@libruby_available)
+      end
+    end
+  end
+end

data/lib/prebake.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "prebake/logger"
+require_relative "prebake/static_ruby"
 
 module Prebake
   class Error < StandardError; end
@@ -19,6 +20,18 @@ 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.optional_native_extensions = StaticRuby.optional_native_extensions
+  def self.optional_native_extension?(gem_name) = StaticRuby.optional_native_extension?(gem_name)
+  def self.libruby_available? = StaticRuby.libruby_available?
+
   def self.backend
     return @backend if defined?(@backend_loaded)
 
@@ -41,6 +54,7 @@ module Prebake
   def self.reset!
     remove_instance_variable(:@backend_loaded) if defined?(@backend_loaded)
     remove_instance_variable(:@backend) if defined?(@backend)
+    StaticRuby.reset!
   end
 
   def self.setup!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prebake
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
 platform: ruby
 authors:
 - Thejus Paul
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 2026-04-23 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,13 +31,17 @@ 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
 - lib/prebake/platform_gem_builder.rb
+- lib/prebake/portability_guard.rb
+- lib/prebake/static_ruby.rb
 - plugins.rb
 homepage: https://github.com/gembakery/prebake
 licenses: