bootsnap 1.17.0 → 1.18.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a17ea0a302554fd131e2941fa8b97b1ff9441750fb4182247bb44d91aa1174e8
-  data.tar.gz: 9ba8386281c2dbb6896b1032e4b6a6c949b81164d54848beac032a977ee43e44
+  metadata.gz: 2b2271b2fa08edc313e43ec1359be530fcb6b206a7b4b63f37065290289cbc9a
+  data.tar.gz: c5838e7d01c33320e765a2bf668c68c09fc6b0938fb8789653b526cb3c22a244
 SHA512:
-  metadata.gz: a1653ddc2779d492f3e5c50719c07a0cdc7a9fab27748dd82096ec923232f9c8b04ddbee738325d13a3aa8c87a38825581677408512437e12933fe18434bcdce
-  data.tar.gz: 9c0f5d4fe058c13577d97011083b7bab23b290cd16b955937b00aaafb5a62239532df4e0d090e576c85dae45dcf504ffa63f9fedd5b2c5dca67afc4457cdbb59
+  metadata.gz: 77168e700a54163bf4574fbf9f82fea681a01f7d0c5c3a55340d3dabc98959fce1176bebef4c4d25d18efa257ad5314f13ca978a77f5cb4288296c63a1b36871
+  data.tar.gz: cc770950cc3032a5033873457a23b19823c35d9d24285f3b13fb95848e51d8f34defca5396c7b545b5530381271979c93026401e4ac32d28ec0f89ceadd57823

data/CHANGELOG.md

@@ -1,9 +1,44 @@
 # Unreleased
 
+# 1.18.4
+
+* Allow using bootsnap without bundler. See #488.
+* Fix startup failure if the cache directory points to a broken symlink.
+
+# 1.18.3
+
+* Fix the cache corruption issue in the revalidation feature. See #474.
+  The cache revalidation feature remains opt-in for now, until it is more battle tested.
+
+# 1.18.2
+
+* Disable stale cache entries revalidation by default as it seems to cause cache corruption issues. See #471 and #474.
+  Will be re-enabled in a future version once the root cause is identified.
+* Fix a potential compilation issue on some systems. See #470.
+
+# 1.18.1
+
+* Handle `EPERM` errors when opening files with `O_NOATIME`.
+
+# 1.18.0
+
+* `Bootsnap.instrumentation` now receive `:hit` events.
+* Add `Bootsnap.log_stats!` to print hit rate statistics on process exit. Can also be enabled with `BOOTSNAP_STATS=1`.
+* Revalidate stale cache entries by digesting the source content.
+  This should significantly improve performance in environments where `mtime` isn't preserved (e.g. CI systems doing a git clone, etc).
+  See #468.
+* Open source files and cache entries with `O_NOATIME` when available to reduce disk accesses. See #469.
+* `bootsnap precompile --gemfile` now look for `.rb` files in the whole gem and not just the `lib/` directory. See #466.
+
+# 1.17.1
+
+* Fix a compatibility issue with the `prism` library that ships with Ruby 3.3. See #463.
+* Improved the `Kernel#require` decorator to not cause a method redefinition warning. See #461.
+
 # 1.17.0
 
-* Ensure `$LOAD_PATH.dup` is Ractor shareable to fix an conflit with `did_you_mean`.
-* Allow to ignore direcotries using absolute paths.
+* Ensure `$LOAD_PATH.dup` is Ractor shareable to fix a conflict with `did_you_mean`.
+* Allow to ignore directories using absolute paths.
 * Support YAML and JSON CompileCache on TruffleRuby.
 * Support LoadPathCache on TruffleRuby.
 
@@ -24,7 +59,7 @@
 * Add a way to skip directories during load path scanning.
   If you have large non-ruby directories in the middle of your load path, it can severely slow down scanning.
   Typically this is a problem with `node_modules`. See #277.
-* Fix `Bootsnap.unload_cache!`, it simply wouldn't work at all becaue of a merge mistake. See #421.
+* Fix `Bootsnap.unload_cache!`, it simply wouldn't work at all because of a merge mistake. See #421.
 
 # 1.13.0
 
@@ -43,7 +78,7 @@
 
 * Stop decorating `Module#autoload` as it was only useful for supporting Ruby 2.2 and older.
 
-* Remove `uname` and other patform specific version from the cache keys. `RUBY_PLATFORM + RUBY_REVISION` should be
+* Remove `uname` and other platform specific version from the cache keys. `RUBY_PLATFORM + RUBY_REVISION` should be
   enough to ensure bytecode compatibility. This should improve caching for alpine based setups. See #409.
 
 # 1.11.1

data/README.md

@@ -81,6 +81,7 @@ well together.
 - `DISABLE_BOOTSNAP_COMPILE_CACHE` allows to disable ISeq and YAML caches.
 - `BOOTSNAP_READONLY` configure bootsnap to not update the cache on miss or stale entries.
 - `BOOTSNAP_LOG` configure bootsnap to log all caches misses to STDERR.
+- `BOOTSNAP_STATS` log hit rate statistics on exit. Can't be used if `BOOTSNAP_LOG` is enabled.
 - `BOOTSNAP_IGNORE_DIRECTORIES` a comma separated list of directories that shouldn't be scanned.
   Useful when you have large directories of non-ruby files inside `$LOAD_PATH`.
   It defaults to ignore any directory named `node_modules`.
@@ -99,8 +100,8 @@ Bootsnap cache misses can be monitored though a callback:
 Bootsnap.instrumentation = ->(event, path) { puts "#{event} #{path}" }
 ```
 
-`event` is either `:miss` or `:stale`. You can also call `Bootsnap.log!` as a shortcut to
-log all events to STDERR.
+`event` is either `:hit`, `:miss`, `:stale` or `:revalidated`.
+You can also call `Bootsnap.log!` as a shortcut to log all events to STDERR.
 
 To turn instrumentation back off you can set it to nil:
 

data/ext/bootsnap/bootsnap.c

@@ -18,8 +18,19 @@
 #include <sys/types.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <unistd.h>
 #include <sys/stat.h>
 
+#ifdef __APPLE__
+  // The symbol is present, however not in the headers
+  // See: https://github.com/Shopify/bootsnap/issues/470
+  extern int fdatasync(int);
+#endif
+
+#ifndef O_NOATIME
+#define O_NOATIME 0
+#endif
+
 /* 1000 is an arbitrary limit; FNV64 plus some slashes brings the cap down to
  * 981 for the cache dir */
 #define MAX_CACHEPATH_SIZE 1000
@@ -30,7 +41,7 @@
 #define MAX_CREATE_TEMPFILE_ATTEMPT 3
 
 #ifndef RB_UNLIKELY
-  #define RB_UNLIKELY(x) (x)
+#define RB_UNLIKELY(x) (x)
 #endif
 
 /*
@@ -54,8 +65,10 @@ struct bs_cache_key {
   uint32_t ruby_revision;
   uint64_t size;
   uint64_t mtime;
-  uint64_t data_size; /* not used for equality */
-  uint8_t  pad[24];
+  uint64_t data_size; //
+  uint64_t digest;
+  uint8_t digest_set;
+  uint8_t pad[15];
 } __attribute__((packed));
 
 /*
@@ -69,7 +82,7 @@ struct bs_cache_key {
 STATIC_ASSERT(sizeof(struct bs_cache_key) == KEY_SIZE);
 
 /* Effectively a schema version. Bumping invalidates all previous caches */
-static const uint32_t current_version = 4;
+static const uint32_t current_version = 6;
 
 /* hash of e.g. "x86_64-darwin17", invalidating when ruby is recompiled on a
  * new OS ABI, etc. */
@@ -87,25 +100,36 @@ static VALUE rb_mBootsnap_CompileCache;
 static VALUE rb_mBootsnap_CompileCache_Native;
 static VALUE rb_cBootsnap_CompileCache_UNCOMPILABLE;
 static ID instrumentation_method;
-static VALUE sym_miss;
-static VALUE sym_stale;
+static VALUE sym_hit, sym_miss, sym_stale, sym_revalidated;
 static bool instrumentation_enabled = false;
 static bool readonly = false;
+static bool revalidation = false;
+static bool perm_issue = false;
 
 /* Functions exposed as module functions on Bootsnap::CompileCache::Native */
 static VALUE bs_instrumentation_enabled_set(VALUE self, VALUE enabled);
 static VALUE bs_readonly_set(VALUE self, VALUE enabled);
+static VALUE bs_revalidation_set(VALUE self, VALUE enabled);
 static VALUE bs_compile_option_crc32_set(VALUE self, VALUE crc32_v);
 static VALUE bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler, VALUE args);
 static VALUE bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler);
 
 /* Helpers */
+enum cache_status {
+  miss,
+  hit,
+  stale,
+};
 static void bs_cache_path(const char * cachedir, const VALUE path, char (* cache_path)[MAX_CACHEPATH_SIZE]);
 static int bs_read_key(int fd, struct bs_cache_key * key);
-static int cache_key_equal(struct bs_cache_key * k1, struct bs_cache_key * k2);
+static enum cache_status cache_key_equal_fast_path(struct bs_cache_key * k1, struct bs_cache_key * k2);
+static int cache_key_equal_slow_path(struct bs_cache_key * current_key, struct bs_cache_key * cached_key, const VALUE input_data);
+static int update_cache_key(struct bs_cache_key *current_key, struct bs_cache_key *old_key, int cache_fd, const char ** errno_provenance);
+
+static void bs_cache_key_digest(struct bs_cache_key * key, const VALUE input_data);
 static VALUE bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args);
 static VALUE bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler);
-static int open_current_file(char * path, struct bs_cache_key * key, const char ** errno_provenance);
+static int open_current_file(const char * path, struct bs_cache_key * key, const char ** errno_provenance);
 static int fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE args, VALUE * output_data, int * exception_tag, const char ** errno_provenance);
 static uint32_t get_ruby_revision(void);
 static uint32_t get_ruby_platform(void);
@@ -122,15 +146,6 @@ struct s2o_data;
 struct i2o_data;
 struct i2s_data;
 
-/* https://bugs.ruby-lang.org/issues/13667 */
-extern VALUE rb_get_coverages(void);
-static VALUE
-bs_rb_coverage_running(VALUE self)
-{
-  VALUE cov = rb_get_coverages();
-  return RTEST(cov) ? Qtrue : Qfalse;
-}
-
 static VALUE
 bs_rb_get_path(VALUE self, VALUE fname)
 {
@@ -161,15 +176,14 @@ Init_bootsnap(void)
 
   instrumentation_method = rb_intern("_instrument");
 
+  sym_hit = ID2SYM(rb_intern("hit"));
   sym_miss = ID2SYM(rb_intern("miss"));
-  rb_global_variable(&sym_miss);
-
   sym_stale = ID2SYM(rb_intern("stale"));
-  rb_global_variable(&sym_stale);
+  sym_revalidated = ID2SYM(rb_intern("revalidated"));
 
   rb_define_module_function(rb_mBootsnap, "instrumentation_enabled=", bs_instrumentation_enabled_set, 1);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "readonly=", bs_readonly_set, 1);
-  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "coverage_running?", bs_rb_coverage_running, 0);
+  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "revalidation=", bs_revalidation_set, 1);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "fetch", bs_rb_fetch, 4);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "precompile", bs_rb_precompile, 3);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "compile_option_crc32=", bs_compile_option_crc32_set, 1);
@@ -185,6 +199,14 @@ bs_instrumentation_enabled_set(VALUE self, VALUE enabled)
   return enabled;
 }
 
+static inline void
+bs_instrumentation(VALUE event, VALUE path)
+{
+    if (RB_UNLIKELY(instrumentation_enabled)) {
+       rb_funcall(rb_mBootsnap, instrumentation_method, 2, event, path);
+    }
+}
+
 static VALUE
 bs_readonly_set(VALUE self, VALUE enabled)
 {
@@ -192,6 +214,13 @@ bs_readonly_set(VALUE self, VALUE enabled)
   return enabled;
 }
 
+static VALUE
+bs_revalidation_set(VALUE self, VALUE enabled)
+{
+  revalidation = RTEST(enabled);
+  return enabled;
+}
+
 /*
  * Bootsnap's ruby code registers a hook that notifies us via this function
  * when compile_option changes. These changes invalidate all existing caches.
@@ -290,17 +319,59 @@ bs_cache_path(const char * cachedir, const VALUE path, char (* cache_path)[MAX_C
  * The data_size member is not compared, as it serves more of a "header"
  * function.
  */
-static int
-cache_key_equal(struct bs_cache_key * k1, struct bs_cache_key * k2)
+static enum cache_status cache_key_equal_fast_path(struct bs_cache_key *k1,
+                                     struct bs_cache_key *k2) {
+  if (k1->version == k2->version &&
+          k1->ruby_platform == k2->ruby_platform &&
+          k1->compile_option == k2->compile_option &&
+          k1->ruby_revision == k2->ruby_revision && k1->size == k2->size) {
+      if (k1->mtime == k2->mtime) {
+        return hit;
+      }
+      if (revalidation) {
+        return stale;
+      }
+  }
+  return miss;
+}
+
+static int cache_key_equal_slow_path(struct bs_cache_key *current_key,
+                                     struct bs_cache_key *cached_key,
+                                     const VALUE input_data)
 {
-  return (
-    k1->version        == k2->version        &&
-    k1->ruby_platform  == k2->ruby_platform  &&
-    k1->compile_option == k2->compile_option &&
-    k1->ruby_revision  == k2->ruby_revision  &&
-    k1->size           == k2->size           &&
-    k1->mtime          == k2->mtime
-  );
+  bs_cache_key_digest(current_key, input_data);
+  return current_key->digest == cached_key->digest;
+}
+
+static int update_cache_key(struct bs_cache_key *current_key, struct bs_cache_key *old_key, int cache_fd, const char ** errno_provenance)
+{
+  old_key->mtime = current_key->mtime;
+  lseek(cache_fd, 0, SEEK_SET);
+  ssize_t nwrite = write(cache_fd, old_key, KEY_SIZE);
+  if (nwrite < 0) {
+      *errno_provenance = "update_cache_key:write";
+      return -1;
+  }
+
+#ifdef HAVE_FDATASYNC
+  if (fdatasync(cache_fd) < 0) {
+      *errno_provenance = "update_cache_key:fdatasync";
+      return -1;
+  }
+#endif
+
+  return 0;
+}
+
+/*
+ * Fills the cache key digest.
+ */
+static void bs_cache_key_digest(struct bs_cache_key *key,
+                                const VALUE input_data) {
+  if (key->digest_set)
+    return;
+  key->digest = fnv1a_64(input_data);
+  key->digest_set = 1;
 }
 
 /*
@@ -356,17 +427,34 @@ bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler)
 
   return bs_precompile(path, path_v, cache_path, handler);
 }
+
+static int bs_open_noatime(const char *path, int flags) {
+  int fd = 1;
+  if (!perm_issue) {
+    fd = open(path, flags | O_NOATIME);
+    if (fd < 0 && errno == EPERM) {
+      errno = 0;
+      perm_issue = true;
+    }
+  }
+
+  if (perm_issue) {
+    fd = open(path, flags);
+  }
+  return fd;
+}
+
 /*
  * Open the file we want to load/cache and generate a cache key for it if it
  * was loaded.
  */
 static int
-open_current_file(char * path, struct bs_cache_key * key, const char ** errno_provenance)
+open_current_file(const char * path, struct bs_cache_key * key, const char ** errno_provenance)
 {
   struct stat statbuf;
   int fd;
 
-  fd = open(path, O_RDONLY);
+  fd = bs_open_noatime(path, O_RDONLY);
   if (fd < 0) {
     *errno_provenance = "bs_fetch:open_current_file:open";
     return fd;
@@ -389,6 +477,7 @@ open_current_file(char * path, struct bs_cache_key * key, const char ** errno_pr
   key->ruby_revision  = current_ruby_revision;
   key->size           = (uint64_t)statbuf.st_size;
   key->mtime          = (uint64_t)statbuf.st_mtime;
+  key->digest_set     = false;
 
   return fd;
 }
@@ -432,7 +521,12 @@ open_cache_file(const char * path, struct bs_cache_key * key, const char ** errn
 {
   int fd, res;
 
-  fd = open(path, O_RDONLY);
+  if (readonly || !revalidation) {
+    fd = bs_open_noatime(path, O_RDONLY);
+  } else {
+    fd = bs_open_noatime(path, O_RDWR);
+  }
+
   if (fd < 0) {
     *errno_provenance = "bs_fetch:open_cache_file:open";
     return CACHE_MISS;
@@ -677,7 +771,8 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
   int res, valid_cache = 0, exception_tag = 0;
   const char * errno_provenance = NULL;
 
-  VALUE input_data;   /* data read from source file, e.g. YAML or ruby source */
+  VALUE status = Qfalse;
+  VALUE input_data = Qfalse;   /* data read from source file, e.g. YAML or ruby source */
   VALUE storage_data; /* compiled data, e.g. msgpack / binary iseq */
   VALUE output_data;  /* return data, e.g. ruby hash or loaded iseq */
 
@@ -695,20 +790,44 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
   cache_fd = open_cache_file(cache_path, &cached_key, &errno_provenance);
   if (cache_fd == CACHE_MISS || cache_fd == CACHE_STALE) {
     /* This is ok: valid_cache remains false, we re-populate it. */
-    if (RB_UNLIKELY(instrumentation_enabled)) {
-      rb_funcall(rb_mBootsnap, instrumentation_method, 2, cache_fd == CACHE_MISS ? sym_miss : sym_stale, path_v);
-    }
+    bs_instrumentation(cache_fd == CACHE_MISS ? sym_miss : sym_stale, path_v);
   } else if (cache_fd < 0) {
     exception_message = rb_str_new_cstr(cache_path);
     goto fail_errno;
   } else {
     /* True if the cache existed and no invalidating changes have occurred since
      * it was generated. */
-    valid_cache = cache_key_equal(&current_key, &cached_key);
-    if (RB_UNLIKELY(instrumentation_enabled)) {
-      if (!valid_cache) {
-        rb_funcall(rb_mBootsnap, instrumentation_method, 2, sym_stale, path_v);
+
+    switch(cache_key_equal_fast_path(&current_key, &cached_key)) {
+    case hit:
+      status = sym_hit;
+      valid_cache = true;
+      break;
+    case miss:
+      valid_cache = false;
+      break;
+    case stale:
+      valid_cache = false;
+      if ((input_data = bs_read_contents(current_fd, current_key.size,
+                                     &errno_provenance)) == Qfalse) {
+        exception_message = path_v;
+        goto fail_errno;
       }
+      valid_cache = cache_key_equal_slow_path(&current_key, &cached_key, input_data);
+      if (valid_cache) {
+        if (!readonly) {
+          if (update_cache_key(&current_key, &cached_key, cache_fd, &errno_provenance)) {
+              exception_message = path_v;
+              goto fail_errno;
+          }
+        }
+        status = sym_revalidated;
+      }
+      break;
+    };
+
+    if (!valid_cache) {
+      status = sym_stale;
     }
   }
 
@@ -722,7 +841,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
     else if (res == CACHE_UNCOMPILABLE) {
       /* If fetch_cached_data returned `Uncompilable` we fallback to `input_to_output`
         This happens if we have say, an unsafe YAML cache, but try to load it in safe mode */
-      if ((input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse){
+      if (input_data == Qfalse && (input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse) {
         exception_message = path_v;
         goto fail_errno;
       }
@@ -741,7 +860,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
   /* Cache is stale, invalid, or missing. Regenerate and write it out. */
 
   /* Read the contents of the source file into a buffer */
-  if ((input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse){
+  if (input_data == Qfalse && (input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse) {
     exception_message = path_v;
     goto fail_errno;
   }
@@ -763,6 +882,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
    * We do however ignore any failures to persist the cache, as it's better
    * to move along, than to interrupt the process.
    */
+  bs_cache_key_digest(&current_key, input_data);
   atomic_write_cache_file(cache_path, &current_key, storage_data, &errno_provenance);
 
   /* Having written the cache, now convert storage_data to output_data */
@@ -793,13 +913,20 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
 
 #define CLEANUP \
   if (current_fd >= 0)  close(current_fd); \
-  if (cache_fd >= 0)    close(cache_fd);
+  if (cache_fd >= 0)    close(cache_fd); \
+  if (status != Qfalse) bs_instrumentation(status, path_v);
 
 succeed:
   CLEANUP;
   return output_data;
 fail_errno:
   CLEANUP;
+  if (errno_provenance) {
+    exception_message = rb_str_concat(
+      rb_str_new_cstr(errno_provenance),
+      rb_str_concat(rb_str_new_cstr(": "), exception_message)
+    );
+  }
   exception = rb_syserr_new_str(errno, exception_message);
   rb_exc_raise(exception);
   __builtin_unreachable();
@@ -818,13 +945,16 @@ invalid_type_storage_data:
 static VALUE
 bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler)
 {
+  if (readonly) {
+    return Qfalse;
+  }
+
   struct bs_cache_key cached_key, current_key;
-  char * contents = NULL;
   int cache_fd = -1, current_fd = -1;
   int res, valid_cache = 0, exception_tag = 0;
   const char * errno_provenance = NULL;
 
-  VALUE input_data;   /* data read from source file, e.g. YAML or ruby source */
+  VALUE input_data = Qfalse;   /* data read from source file, e.g. YAML or ruby source */
   VALUE storage_data; /* compiled data, e.g. msgpack / binary iseq */
 
   /* Open the source file and generate a cache key for it */
@@ -840,7 +970,26 @@ bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler)
   } else {
     /* True if the cache existed and no invalidating changes have occurred since
      * it was generated. */
-    valid_cache = cache_key_equal(&current_key, &cached_key);
+    switch(cache_key_equal_fast_path(&current_key, &cached_key)) {
+    case hit:
+      valid_cache = true;
+      break;
+    case miss:
+      valid_cache = false;
+      break;
+    case stale:
+      valid_cache = false;
+      if ((input_data = bs_read_contents(current_fd, current_key.size, &errno_provenance)) == Qfalse) {
+        goto fail;
+      }
+      valid_cache = cache_key_equal_slow_path(&current_key, &cached_key, input_data);
+       if (valid_cache) {
+         if (update_cache_key(&current_key, &cached_key, cache_fd, &errno_provenance)) {
+             goto fail;
+         }
+      }
+      break;
+    };
   }
 
   if (valid_cache) {
@@ -867,6 +1016,7 @@ bs_precompile(char * path, VALUE path_v, char * cache_path, VALUE handler)
   if (!RB_TYPE_P(storage_data, T_STRING)) goto fail;
 
   /* Write the cache key and storage_data to the cache directory */
+  bs_cache_key_digest(&current_key, input_data);
   res = atomic_write_cache_file(cache_path, &current_key, storage_data, &errno_provenance);
   if (res < 0) goto fail;
 

data/ext/bootsnap/extconf.rb

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
-require("mkmf")
+require "mkmf"
 
 if %w[ruby truffleruby].include?(RUBY_ENGINE)
-  $CFLAGS << " -O3 "
-  $CFLAGS << " -std=c99"
+  have_func "fdatasync", "unistd.h"
+
+  unless RUBY_PLATFORM.match?(/mswin|mingw|cygwin/)
+    append_cppflags ["-D_GNU_SOURCE"] # Needed of O_NOATIME
+  end
+
+  append_cflags ["-O3", "-std=c99"]
 
   # ruby.h has some -Wpedantic fails in some cases
   # (e.g. https://github.com/Shopify/bootsnap/issues/15)
   unless ["0", "", nil].include?(ENV["BOOTSNAP_PEDANTIC"])
-    $CFLAGS << " -Wall"
-    $CFLAGS << " -Werror"
-    $CFLAGS << " -Wextra"
-    $CFLAGS << " -Wpedantic"
+    append_cflags([
+      "-Wall",
+      "-Werror",
+      "-Wextra",
+      "-Wpedantic",
 
-    $CFLAGS << " -Wno-unused-parameter" # VALUE self has to be there but we don't care what it is.
-    $CFLAGS << " -Wno-keyword-macro" # hiding return
-    $CFLAGS << " -Wno-gcc-compat" # ruby.h 2.6.0 on macos 10.14, dunno
-    $CFLAGS << " -Wno-compound-token-split-by-macro"
+      "-Wno-unused-parameter", # VALUE self has to be there but we don't care what it is.
+      "-Wno-keyword-macro", # hiding return
+      "-Wno-gcc-compat", # ruby.h 2.6.0 on macos 10.14, dunno
+      "-Wno-compound-token-split-by-macro",
+    ])
   end
 
   create_makefile("bootsnap/bootsnap")

data/lib/bootsnap/bundler.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  extend(self)
+  extend self
 
   def bundler?
     return false unless defined?(::Bundler)

data/lib/bootsnap/cli.rb

@@ -36,16 +36,16 @@ module Bootsnap
     end
 
     def precompile_command(*sources)
-      require "bootsnap/compile_cache/iseq"
-      require "bootsnap/compile_cache/yaml"
-      require "bootsnap/compile_cache/json"
+      require "bootsnap/compile_cache"
 
       fix_default_encoding do
-        Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
-        Bootsnap::CompileCache::YAML.init!
-        Bootsnap::CompileCache::YAML.cache_dir = cache_dir
-        Bootsnap::CompileCache::JSON.init!
-        Bootsnap::CompileCache::JSON.cache_dir = cache_dir
+        Bootsnap::CompileCache.setup(
+          cache_dir: cache_dir,
+          iseq: iseq,
+          yaml: yaml,
+          json: json,
+          revalidation: true,
+        )
 
         @work_pool = WorkerPool.create(size: jobs, jobs: {
           ruby: method(:precompile_ruby),
@@ -60,14 +60,16 @@ module Bootsnap
         precompile_json_files(main_sources)
 
         if compile_gemfile
-          # Some gems embed their tests, they're very unlikely to be loaded, so not worth precompiling.
-          gem_exclude = Regexp.union([exclude, "/spec/", "/test/"].compact)
-          precompile_ruby_files($LOAD_PATH.map { |d| File.expand_path(d) }, exclude: gem_exclude)
-
           # Gems that include JSON or YAML files usually don't put them in `lib/`.
           # So we look at the gem root.
+          # Similarly, gems that include Rails engines generally file Ruby files in `app/`.
+          # However some gems embed their tests, they're very unlikely to be loaded, so not worth precompiling.
+          gem_exclude = Regexp.union([exclude, "/spec/", "/test/", "/features/"].compact)
+
           gem_pattern = %r{^#{Regexp.escape(Bundler.bundle_path.to_s)}/?(?:bundler/)?gems/[^/]+}
-          gem_paths = $LOAD_PATH.map { |p| p[gem_pattern] }.compact.uniq
+          gem_paths = $LOAD_PATH.map { |p| p[gem_pattern] || p }.uniq
+
+          precompile_ruby_files(gem_paths, exclude: gem_exclude)
           precompile_yaml_files(gem_paths, exclude: gem_exclude)
           precompile_json_files(gem_paths, exclude: gem_exclude)
         end
@@ -220,6 +222,9 @@ module Bootsnap
 
     def parser
       @parser ||= OptionParser.new do |opts|
+        opts.version = Bootsnap::VERSION
+        opts.program_name = "bootsnap"
+
         opts.banner = "Usage: bootsnap COMMAND [ARGS]"
         opts.separator ""
         opts.separator "GLOBAL OPTIONS"

data/lib/bootsnap/compile_cache/iseq.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require("bootsnap/bootsnap")
-require("zlib")
+require "bootsnap/bootsnap"
+require "zlib"
 
 module Bootsnap
   module CompileCache
@@ -84,7 +84,7 @@ module Bootsnap
       module InstructionSequenceMixin
         def load_iseq(path)
           # Having coverage enabled prevents iseq dumping/loading.
-          return nil if defined?(Coverage) && Bootsnap::CompileCache::Native.coverage_running?
+          return nil if defined?(Coverage) && Coverage.running?
 
           Bootsnap::CompileCache::ISeq.fetch(path.to_s)
         rescue RuntimeError => error

data/lib/bootsnap/compile_cache/json.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require("bootsnap/bootsnap")
+require "bootsnap/bootsnap"
 
 module Bootsnap
   module CompileCache
@@ -46,8 +46,8 @@ module Bootsnap
         end
 
         def init!
-          require("json")
-          require("msgpack")
+          require "json"
+          require "msgpack"
 
           self.msgpack_factory = MessagePack::Factory.new
           self.supported_options = [:symbolize_names]

data/lib/bootsnap/compile_cache/yaml.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require("bootsnap/bootsnap")
+require "bootsnap/bootsnap"
 
 module Bootsnap
   module CompileCache
@@ -55,9 +55,9 @@ module Bootsnap
         end
 
         def init!
-          require("yaml")
-          require("msgpack")
-          require("date")
+          require "yaml"
+          require "msgpack"
+          require "date"
 
           @implementation = ::YAML::VERSION >= "4" ? Psych4 : Psych3
           if @implementation::Patch.method_defined?(:unsafe_load_file) && !::YAML.respond_to?(:unsafe_load_file)

data/lib/bootsnap/compile_cache.rb

@@ -9,10 +9,10 @@ module Bootsnap
 
     Error = Class.new(StandardError)
 
-    def self.setup(cache_dir:, iseq:, yaml:, json:, readonly: false)
+    def self.setup(cache_dir:, iseq:, yaml:, json:, readonly: false, revalidation: false)
       if iseq
         if supported?
-          require_relative("compile_cache/iseq")
+          require_relative "compile_cache/iseq"
           Bootsnap::CompileCache::ISeq.install!(cache_dir)
         elsif $VERBOSE
           warn("[bootsnap/setup] bytecode caching is not supported on this implementation of Ruby")
@@ -21,7 +21,7 @@ module Bootsnap
 
       if yaml
         if supported?
-          require_relative("compile_cache/yaml")
+          require_relative "compile_cache/yaml"
           Bootsnap::CompileCache::YAML.install!(cache_dir)
         elsif $VERBOSE
           warn("[bootsnap/setup] YAML parsing caching is not supported on this implementation of Ruby")
@@ -30,7 +30,7 @@ module Bootsnap
 
       if json
         if supported?
-          require_relative("compile_cache/json")
+          require_relative "compile_cache/json"
           Bootsnap::CompileCache::JSON.install!(cache_dir)
         elsif $VERBOSE
           warn("[bootsnap/setup] JSON parsing caching is not supported on this implementation of Ruby")
@@ -39,6 +39,7 @@ module Bootsnap
 
       if supported? && defined?(Bootsnap::CompileCache::Native)
         Bootsnap::CompileCache::Native.readonly = readonly
+        Bootsnap::CompileCache::Native.revalidation = revalidation
       end
     end
 

data/lib/bootsnap/explicit_require.rb

@@ -25,6 +25,11 @@ module Bootsnap
     # This is useful before bootsnap is fully-initialized to load gems that it
     # depends on, without forcing full LOAD_PATH traversals.
     def self.with_gems(*gems)
+      # Ensure the gems are activated (their paths are in $LOAD_PATH)
+      gems.each do |gem_name|
+        gem gem_name
+      end
+
       orig = $LOAD_PATH.dup
       $LOAD_PATH.clear
       gems.each do |gem|

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative("../explicit_require")
+require_relative "../explicit_require"
 
 module Bootsnap
   module LoadPathCache

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Kernel
-  module_function
+  alias_method :require_without_bootsnap, :require
 
-  alias_method(:require_without_bootsnap, :require)
+  alias_method :require, :require # Avoid method redefinition warnings
 
-  def require(path)
+  def require(path) # rubocop:disable Lint/DuplicateMethods
     return require_without_bootsnap(path) unless Bootsnap::LoadPathCache.enabled?
 
     string_path = Bootsnap.rb_get_path(path)
@@ -24,9 +24,7 @@ module Kernel
     elsif false == resolved
       return false
     elsif resolved.nil?
-      error = LoadError.new(+"cannot load such file -- #{path}")
-      error.instance_variable_set(:@path, path)
-      raise error
+      return require_without_bootsnap(path)
     else
       # Note that require registers to $LOADED_FEATURES while load does not.
       ret = require_without_bootsnap(resolved)
@@ -34,4 +32,6 @@ module Kernel
       return ret
     end
   end
+
+  private :require
 end

data/lib/bootsnap/load_path_cache/path.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative("path_scanner")
+require_relative "path_scanner"
 
 module Bootsnap
   module LoadPathCache

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative("../explicit_require")
+require_relative "../explicit_require"
 
 module Bootsnap
   module LoadPathCache

data/lib/bootsnap/load_path_cache/store.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative("../explicit_require")
+require_relative "../explicit_require"
 
-Bootsnap::ExplicitRequire.with_gems("msgpack") { require("msgpack") }
+Bootsnap::ExplicitRequire.with_gems("msgpack") { require "msgpack" }
 
 module Bootsnap
   module LoadPathCache
@@ -122,6 +122,8 @@ module Bootsnap
         stack.reverse_each do |dir|
           Dir.mkdir(dir)
         rescue SystemCallError
+          # Check for broken symlinks. Calling File.realpath will raise Errno::ENOENT if that is the case
+          File.realpath(dir) if File.symlink?(dir)
           raise unless File.directory?(dir)
         end
       end

data/lib/bootsnap/load_path_cache.rb

@@ -41,8 +41,8 @@ module Bootsnap
         PathScanner.ignored_directories = ignore_directories if ignore_directories
         @load_path_cache = Cache.new(store, $LOAD_PATH, development_mode: development_mode)
         @enabled = true
-        require_relative("load_path_cache/core_ext/kernel_require")
-        require_relative("load_path_cache/core_ext/loaded_features")
+        require_relative "load_path_cache/core_ext/kernel_require"
+        require_relative "load_path_cache/core_ext/loaded_features"
       end
 
       def unload!
@@ -71,10 +71,10 @@ module Bootsnap
 end
 
 if Bootsnap::LoadPathCache.supported?
-  require_relative("load_path_cache/path_scanner")
-  require_relative("load_path_cache/path")
-  require_relative("load_path_cache/cache")
-  require_relative("load_path_cache/store")
-  require_relative("load_path_cache/change_observer")
-  require_relative("load_path_cache/loaded_features_index")
+  require_relative "load_path_cache/path_scanner"
+  require_relative "load_path_cache/path"
+  require_relative "load_path_cache/cache"
+  require_relative "load_path_cache/store"
+  require_relative "load_path_cache/change_observer"
+  require_relative "load_path_cache/loaded_features_index"
 end

data/lib/bootsnap/setup.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative("../bootsnap")
+require_relative "../bootsnap"
 
 Bootsnap.default_setup

data/lib/bootsnap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.17.0"
+  VERSION = "1.18.4"
 end

data/lib/bootsnap.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative("bootsnap/version")
-require_relative("bootsnap/bundler")
-require_relative("bootsnap/load_path_cache")
-require_relative("bootsnap/compile_cache")
+require_relative "bootsnap/version"
+require_relative "bootsnap/bundler"
+require_relative "bootsnap/load_path_cache"
+require_relative "bootsnap/compile_cache"
 
 module Bootsnap
   InvalidConfiguration = Class.new(StandardError)
@@ -11,6 +11,16 @@ module Bootsnap
   class << self
     attr_reader :logger
 
+    def log_stats!
+      stats = {hit: 0, revalidated: 0, miss: 0, stale: 0}
+      self.instrumentation = ->(event, _path) { stats[event] += 1 }
+      Kernel.at_exit do
+        stats.each do |event, count|
+          $stderr.puts "bootsnap #{event}: #{count}"
+        end
+      end
+    end
+
     def log!
       self.logger = $stderr.method(:puts)
     end
@@ -18,9 +28,9 @@ module Bootsnap
     def logger=(logger)
       @logger = logger
       self.instrumentation = if logger.respond_to?(:debug)
-        ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") }
+        ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") unless event == :hit }
       else
-        ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") }
+        ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") unless event == :hit }
       end
     end
 
@@ -41,6 +51,7 @@ module Bootsnap
       load_path_cache: true,
       ignore_directories: nil,
       readonly: false,
+      revalidation: false,
       compile_cache_iseq: true,
       compile_cache_yaml: true,
       compile_cache_json: true
@@ -60,6 +71,7 @@ module Bootsnap
         yaml: compile_cache_yaml,
         json: compile_cache_json,
         readonly: readonly,
+        revalidation: revalidation,
       )
     end
 
@@ -71,7 +83,7 @@ module Bootsnap
       env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["ENV"]
       development_mode = ["", nil, "development"].include?(env)
 
-      unless ENV["DISABLE_BOOTSNAP"]
+      if enabled?("BOOTSNAP")
         cache_dir = ENV["BOOTSNAP_CACHE_DIR"]
         unless cache_dir
           config_dir_frame = caller.detect do |line|
@@ -100,16 +112,19 @@ module Bootsnap
         setup(
           cache_dir: cache_dir,
           development_mode: development_mode,
-          load_path_cache: !ENV["DISABLE_BOOTSNAP_LOAD_PATH_CACHE"],
-          compile_cache_iseq: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-          compile_cache_yaml: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-          compile_cache_json: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-          readonly: !!ENV["BOOTSNAP_READONLY"],
+          load_path_cache: enabled?("BOOTSNAP_LOAD_PATH_CACHE"),
+          compile_cache_iseq: enabled?("BOOTSNAP_COMPILE_CACHE"),
+          compile_cache_yaml: enabled?("BOOTSNAP_COMPILE_CACHE"),
+          compile_cache_json: enabled?("BOOTSNAP_COMPILE_CACHE"),
+          readonly: bool_env("BOOTSNAP_READONLY"),
+          revalidation: bool_env("BOOTSNAP_REVALIDATE"),
           ignore_directories: ignore_directories,
         )
 
         if ENV["BOOTSNAP_LOG"]
           log!
+        elsif ENV["BOOTSNAP_STATS"]
+          log_stats!
         end
       end
     end
@@ -134,5 +149,16 @@ module Bootsnap
 
     # Allow the C extension to redefine `rb_get_path` without warning.
     alias_method :rb_get_path, :rb_get_path # rubocop:disable Lint/DuplicateMethods
+
+    private
+
+    def enabled?(key)
+      !ENV["DISABLE_#{key}"]
+    end
+
+    def bool_env(key, default: false)
+      value = ENV.fetch(key) { default }
+      !["0", "false", false].include?(value)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.17.0
+  version: 1.18.4
 platform: ruby
 authors:
 - Burke Libbey
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-30 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -68,7 +68,7 @@ metadata:
   changelog_uri: https://github.com/Shopify/bootsnap/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/Shopify/bootsnap
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -83,8 +83,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []