bootsnap 1.4.1-java → 1.4.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: bbe2d60be7b9970d1b993f144e28071bf85ebb528f24df8afbc00e5f4a1df6da
-  data.tar.gz: 2cda0fdec14bcedf1c6e232e75380ee7cabbdec2953428912563a83c39bb9472
+SHA1:
+  metadata.gz: 4e355bad836c2faeacff354f3b026f03401171c4
+  data.tar.gz: 89cb1e0c808975099905f5ba9a7ee7cea58e9338
 SHA512:
-  metadata.gz: 1b8b3cb9986921f82c8c3489c37e33a576587d93ef09fc94b5c7e16e6682d86c54283b34bc659b2a5f1bb60f14d2c1ae272ef2e4a3089d623a36e6e4529c5629
-  data.tar.gz: 85efef308c58141634984fbda14d393f7555333456c57b99e10ae7f8ddc592c3623cbefd0ffc34c2217092407014667dad3744b4b86d367a0f91a82df3f9853c
+  metadata.gz: bc454087a30b54b6735ba8c8640f640261a5cd5f232fec2edf53438b868e74ef8e178bcd03e5a083f46188e5049776bbf4e3981cc7fea13927d24081e94f1cdf
+  data.tar.gz: 234c23ed91b2632db1bddae904a3d0c319016e84616172d9aaed0a666188ceeca9803d2f6d85f642a7917815fc094f352645938cd4b9f2fa9136658d137b2314

data/.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# mvm:maintainer
+* @burke

data/.github/probots.yml

@@ -0,0 +1,2 @@
+enabled:
+  - cla

data/.travis.yml

@@ -17,8 +17,5 @@ matrix:
     - rvm: jruby
       os: linux
       env: MINIMAL_SUPPORT=1
-    - rvm: truffleruby
-      os: linux
-      env: MINIMAL_SUPPORT=1
 
 script: bin/ci

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.4.2
+
+* Fix bug when removing features loaded by relative path from `$LOADED_FEATURES`
+* Fix bug with propagation of `NameError` up from nested calls to `require`
+
 # 1.4.1
 
 * Don't register change observers to frozen objects.

data/README.md

@@ -4,9 +4,14 @@ Bootsnap is a library that plugs into Ruby, with optional support for `ActiveSup
 to optimize and cache expensive computations. See [How Does This Work](#how-does-this-work).
 
 #### Performance
-- [Discourse](https://github.com/discourse/discourse) reports a boot time reduction of approximately 50%, from roughly 6 to 3 seconds on one machine;
+
+- [Discourse](https://github.com/discourse/discourse) reports a boot time reduction of approximately
+  50%, from roughly 6 to 3 seconds on one machine;
 - One of our smaller internal apps also sees a reduction of 50%, from 3.6 to 1.8 seconds;
-- The core Shopify platform -- a rather large monolithic application -- boots about 75% faster, dropping from around 25s to 6.5s.
+- The core Shopify platform -- a rather large monolithic application -- boots about 75% faster,
+  dropping from around 25s to 6.5s.
+* In Shopify core (a large app), about 25% of this gain can be attributed to `compile_cache_*`
+  features; 75% to path caching, and ~1% to `disable_trace`. This is fairly representative.
 
 ## Usage
 
@@ -28,6 +33,10 @@ Note that bootsnap writes to `tmp/cache`, and that directory *must* be writable.
 boot if it is not. If this is unacceptable (e.g. you are running in a read-only container and
 unwilling to mount in a writable tmpdir), you should remove this line or wrap it in a conditional.
 
+**Note also that bootsnap will never clean up its own cache: this is left up to you. Depending on your
+deployment strategy, you may need to periodically purge `tmp/cache/bootsnap*`. If you notice deploys
+getting progressively slower, this is almost certainly the cause.**
+
 It's technically possible to simply specify `gem 'bootsnap', require: 'bootsnap/setup'`, but it's
 important to load Bootsnap as early as possible to get maximum performance improvement.
 
@@ -284,3 +293,12 @@ open    /c/nope.bundle -> -1
 ```
 # (nothing!)
 ```
+
+## When not to use Bootsnap
+
+*Alternative engines*: Bootsnap is pretty reliant on MRI features, and parts are disabled entirely on alternative ruby
+engines.
+
+*Non-local filesystems*: Bootsnap depends on `tmp/cache` (or whatever you set its cache directory
+to) being on a relatively fast filesystem. If you put it on a network mount, bootsnap is very likely
+to slow your application down quite a lot.

data/ext/bootsnap/bootsnap.c

@@ -468,21 +468,21 @@ static int
 atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char ** errno_provenance)
 {
   char template[MAX_CACHEPATH_SIZE + 20];
-  char * dest;
   char * tmp_path;
   int fd, ret;
   ssize_t nwrite;
 
-  dest = strncpy(template, path, MAX_CACHEPATH_SIZE);
-  strcat(dest, ".tmp.XXXXXX");
+  tmp_path = strncpy(template, path, MAX_CACHEPATH_SIZE);
+  strcat(tmp_path, ".tmp.XXXXXX");
 
-  tmp_path = mktemp(template);
-  fd = open(tmp_path, O_WRONLY | O_CREAT, 0664);
+  // mkstemp modifies the template to be the actual created path
+  fd = mkstemp(tmp_path);
   if (fd < 0) {
-    if (mkpath(path, 0775) < 0) {
+    if (mkpath(tmp_path, 0775) < 0) {
       *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:mkpath";
       return -1;
     }
+    close(fd);
     fd = open(tmp_path, O_WRONLY | O_CREAT, 0664);
     if (fd < 0) {
       *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:open";

data/lib/bootsnap/compile_cache.rb

@@ -1,5 +1,8 @@
 module Bootsnap
   module CompileCache
+    Error           = Class.new(StandardError)
+    PermissionError = Class.new(Error)
+
     def self.setup(cache_dir:, iseq:, yaml:)
       if iseq
         if supported?
@@ -20,6 +23,15 @@ module Bootsnap
       end
     end
 
+    def self.permission_error(path)
+      cpath = Bootsnap::CompileCache::ISeq.cache_dir
+      raise(
+        PermissionError,
+        "bootsnap doesn't have permission to write cache entries in '#{cpath}' " \
+        "(or, less likely, doesn't have permisison to read '#{path}')",
+      )
+    end
+
     def self.supported?
       # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), and >= 2.3.0
       RUBY_ENGINE == 'ruby' &&

data/lib/bootsnap/compile_cache/iseq.rb

@@ -39,6 +39,8 @@ module Bootsnap
             path.to_s,
             Bootsnap::CompileCache::ISeq
           )
+        rescue Errno::EACCES
+          Bootsnap::CompileCache.permission_error(path)
         rescue RuntimeError => e
           if e.message =~ /unmatched platform/
             puts("unmatched platform for file #{path}")

data/lib/bootsnap/compile_cache/yaml.rb

@@ -46,11 +46,15 @@ module Bootsnap
 
         klass = class << ::YAML; self; end
         klass.send(:define_method, :load_file) do |path|
-          Bootsnap::CompileCache::Native.fetch(
-            cache_dir,
-            path,
-            Bootsnap::CompileCache::YAML
-          )
+          begin
+            Bootsnap::CompileCache::Native.fetch(
+              cache_dir,
+              path,
+              Bootsnap::CompileCache::YAML
+            )
+          rescue Errno::EACCES
+            Bootsnap::CompileCache.permission_error(path)
+          end
         end
       end
     end

data/lib/bootsnap/load_path_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     ReturnFalse = Class.new(StandardError)
@@ -7,6 +9,11 @@ module Bootsnap
     DOT_SO = '.so'
     SLASH  = '/'
 
+    # If a NameError happens several levels deep, don't re-handle it
+    # all the way up the chain: mark it once and bubble it up without
+    # more retries.
+    ERROR_TAG_IVAR = :@__bootsnap_rescued
+
     DL_EXTENSIONS = ::RbConfig::CONFIG
       .values_at('DLEXT', 'DLEXT2')
       .reject { |ext| !ext || ext.empty? }

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative('../explicit_require')
 
 module Bootsnap
@@ -46,7 +48,7 @@ module Bootsnap
         reinitialize if (@has_relative_paths && dir_changed?) || stale?
         feature = feature.to_s
         return feature if absolute_path?(feature)
-        return File.expand_path(feature) if feature.start_with?('./')
+        return expand_path(feature) if feature.start_with?('./')
         @mutex.synchronize do
           x = search_index(feature)
           return x if x
@@ -162,6 +164,10 @@ module Bootsnap
         end
       end
 
+      def expand_path(feature)
+        maybe_append_extension(File.expand_path(feature))
+      end
+
       def stale?
         @development_mode && @generated_at + AGE_THRESHOLD < now
       end
@@ -174,10 +180,18 @@ module Bootsnap
         def search_index(f)
           try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f + DLEXT2) || try_index(f)
         end
+
+        def maybe_append_extension(f)
+          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || try_ext(f + DLEXT2) || f
+        end
       else
         def search_index(f)
           try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f)
         end
+
+        def maybe_append_extension(f)
+          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || f
+        end
       end
 
       def try_index(f)
@@ -185,6 +199,10 @@ module Bootsnap
           p + '/' + f
         end
       end
+
+      def try_ext(f)
+        f if File.exist?(f)
+      end
     end
   end
 end

data/lib/bootsnap/load_path_cache/core_ext/active_support.rb

@@ -60,19 +60,22 @@ module Bootsnap
               super
             end
           rescue NameError => e
+            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
+            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+
             # This function can end up called recursively, we only want to
             # retry at the top-level.
-            raise if Thread.current[:without_bootsnap_retry]
+            raise(e) if Thread.current[:without_bootsnap_retry]
             # If we already had cache disabled, there's no use retrying
-            raise if Thread.current[:without_bootsnap_cache]
+            raise(e) if Thread.current[:without_bootsnap_cache]
             # NoMethodError is a NameError, but we only want to handle actual
             # NameError instances.
-            raise unless e.class == NameError
+            raise(e) unless e.class == NameError
             # We can only confidently handle cases when *this* constant fails
             # to load, not other constants referred to by it.
-            raise unless e.name == const_name
+            raise(e) unless e.name == const_name
             # If the constant was actually loaded, something else went wrong?
-            raise if from_mod.const_defined?(const_name)
+            raise(e) if from_mod.const_defined?(const_name)
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
 
@@ -80,9 +83,12 @@ module Bootsnap
           # reiterate it with version polymorphism here...
           def depend_on(*)
             super
-          rescue LoadError
+          rescue LoadError => e
+            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
+            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+
             # If we already had cache disabled, there's no use retrying
-            raise if Thread.current[:without_bootsnap_cache]
+            raise(e) if Thread.current[:without_bootsnap_cache]
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
         end

data/lib/bootsnap/load_path_cache/core_ext/kernel_require.rb

@@ -3,6 +3,7 @@ module Bootsnap
     module CoreExt
       def self.make_load_error(path)
         err = LoadError.new("cannot load such file -- #{path}")
+        err.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
         err.define_singleton_method(:path) { path }
         err
       end
@@ -30,6 +31,9 @@ module Kernel
     end
 
     raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
+  rescue LoadError => e
+    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+    raise(e)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
@@ -56,6 +60,9 @@ module Kernel
     end
 
     raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
+  rescue LoadError => e
+    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+    raise(e)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
@@ -74,6 +81,9 @@ class Module
     # added to $LOADED_FEATURES and won't be able to hook that modification
     # since it's done in C-land.
     autoload_without_bootsnap(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || path)
+  rescue LoadError => e
+    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+    raise(e)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan

data/lib/bootsnap/load_path_cache/core_ext/loaded_features.rb

@@ -4,4 +4,14 @@ class << $LOADED_FEATURES
     Bootsnap::LoadPathCache.loaded_features_index.purge(key)
     delete_without_bootsnap(key)
   end
+
+  alias_method(:reject_without_bootsnap!, :reject!)
+  def reject!(&block)
+    backup = dup
+
+    # FIXME: if no block is passed we'd need to return a decorated iterator
+    reject_without_bootsnap!(&block)
+
+    Bootsnap::LoadPathCache.loaded_features_index.purge_multi(backup - self)
+  end
 end

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     # LoadedFeaturesIndex partially mirrors an internal structure in ruby that
@@ -55,6 +57,13 @@ module Bootsnap
         end
       end
 
+      def purge_multi(features)
+        rejected_hashes = features.map(&:hash).to_set
+        @mutex.synchronize do
+          @lfi.reject! { |_, hash| rejected_hashes.include?(hash) }
+        end
+      end
+
       def key?(feature)
         @mutex.synchronize { @lfi.key?(feature) }
       end

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative('../explicit_require')
 
 module Bootsnap
@@ -11,7 +13,7 @@ module Bootsnap
       BUNDLE_PATH = if Bootsnap.bundler?
         (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
       else
-        ''.freeze
+        ''
       end
 
       def self.call(path)

data/lib/bootsnap/load_path_cache/store.rb

@@ -60,9 +60,11 @@ module Bootsnap
       def load_data
         @data = begin
           MessagePack.load(File.binread(@store_path))
-                # handle malformed data due to upgrade incompatability
-                rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
-                  {}
+          # handle malformed data due to upgrade incompatability
+        rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
+          {}
+        rescue ArgumentError => e
+          e.message =~ /negative array size/ ? {} : raise
         end
       end
 

data/lib/bootsnap/version.rb

@@ -1,3 +1,3 @@
 module Bootsnap
-  VERSION = "1.4.1"
+  VERSION = "1.4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
 platform: java
 authors:
 - Burke Libbey
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-02-25 00:00:00.000000000 Z
+date: 2019-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -101,6 +101,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/CODEOWNERS"
+- ".github/probots.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".travis.yml"
@@ -165,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.7.6
+rubygems_version: 2.4.8
 signing_key:
 specification_version: 4
 summary: Boot large ruby/rails apps faster