railwatch 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6efded747b3ad71d6a52964ab2d2f32b7a94a862a706d573ac983f013c720b75
-  data.tar.gz: 7310f931fc2f1215acf83345a7469c554be1692185fd76fb5f7af1d9fe80637e
+  metadata.gz: 9c88b489c82195c106d414c397d391d8cf2e8d3e499dd67715d3db14fc4f7dae
+  data.tar.gz: 3a2bb00def3c244d0eb9630f1eb6b3d4fddb29ea17cf34e2c8023123c92bdaf3
 SHA512:
-  metadata.gz: 74988c5b9f75e56774d8166c0c30fc4d87a9f23b22fed11e3b3d05b6e2b5044da1e069eaadce118ee7a84ec307d1f043bc1852b59e2b375a09f5ea6323368672
-  data.tar.gz: 0d183de6bf27ce94efb729b5000d7e37225520e1fe5fd38574392893bf7e8b0f2a3b170cf98bab74394b83bd08976b8726b8d5a919cffd1a5c793e4141fc4e59
+  metadata.gz: f616d461f05f956503d2fa37d20dd238f98f1f77624665e6c352c675b9df12704b2a912e15b8bcf6d992192a86016b3ee39e8924b7b4a70d9bbe24f61d5c4845
+  data.tar.gz: 8d372cfaed4dd585b39a8bbd6f042b9af6bada233e92dc7e0021613507e6bc0d570cc120bce4f1f5ef163c223ea8855a730781c16bc5fd34321a9cff10020607

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.3.3 (2026-09-19)
+
+- Fix `railwatch:install --local` writing test databases that parallel test
+  runners cannot share. The generated `test` entries named
+  `storage/test_railwatch*.sqlite3` with no `TEST_ENV_NUMBER`, so every worker
+  in a parallel run opened the same two SQLite files and raced through them:
+  `ActiveRecord::PendingMigrationError` and `SQLite3::IOException: disk I/O
+  error` out of `configure_connection`, on every shard. Rails' own test
+  database naming carries the number for this reason, and the generated names
+  now do too. An app with no parallel runner sets no `TEST_ENV_NUMBER`, so its
+  generated file is unchanged and no existing install needs migrating.
+
+## 0.3.2 (2026-09-19)
+
+- Fix an embedded install's rake tasks reporting over HTTP instead of into
+  the app's own database. A rake process invokes its top-level task -- where
+  the command patch starts the execution, and sampling it builds the
+  reporter -- before that task's `:environment` prerequisite boots Rails and
+  runs `config/initializers`. A token in the environment is enough for
+  Railwatch to be enabled that early, so the reporter chose HTTP from a
+  config that had not yet been told the app is embedded, and kept it.
+  Every rake task's telemetry then went to the receiver instead of the
+  local database, skipping the export queue and the replay receipt it
+  earns. Affects embedded and hybrid installs with a token configured;
+  cloud-only installs were never affected, and neither was an embedded
+  install with no token.
+- The reporter now re-decides what it derived from a not-yet-final config
+  once `config/initializers` has run: its transport, and its buffer size
+  while that buffer is still empty.
+- Add a subprocess regression that reproduces rake's ordering and fails if
+  an embedded app's rake task reports over HTTP.
+
 ## 0.3.1 (2026-09-19)
 
 - Fix production boot for cloud-only installs with no Railwatch databases.

data/lib/generators/railwatch/install/install_generator.rb

@@ -383,12 +383,26 @@ module Railwatch
             lines.insert(start + 1, "  primary:\n")
             stop += 1
           end
-          entries = format(RAILWATCH_DATABASES, env: env).lines.map { |line| "  #{line}" }
+          entries = format(RAILWATCH_DATABASES, env: database_prefix(env)).lines.map { |line| "  #{line}" }
           lines = insert_lines(lines, stop, entries.join).lines
         end
         lines.join
       end
 
+      # What the database filenames are built from. For test that has to carry
+      # TEST_ENV_NUMBER, the way Rails' own test database naming does: runners
+      # like parallel_tests give each worker its own number and expect a
+      # database per worker. Without it every worker in a run opens the same
+      # two SQLite files and they fight over them -- observed as
+      # PendingMigrationError and "disk I/O error" from configure_connection,
+      # on an app running four workers. An app with no such runner sets no
+      # TEST_ENV_NUMBER, so the suffix is empty and the name is unchanged.
+      def self.database_prefix(env)
+        return env unless env == "test"
+
+        %(test<%= ENV["TEST_ENV_NUMBER"] %>)
+      end
+
       # Unconditional: `bundle exec puma` evaluates this file before it loads
       # the Rack app, so `if defined?(Railwatch)` would be false there and the
       # writer would never start. The plugin itself is inert when Railwatch is

data/lib/railwatch/engine.rb

@@ -112,6 +112,15 @@ module Railwatch
       end
     end
 
+    # A rake process starts its command execution before this point -- the
+    # top-level task is invoked before its `:environment` prerequisite boots
+    # Rails -- so a reporter can already exist, built from a config that had
+    # not yet been told the app is embedded. This is the first moment the
+    # app's own configuration is final.
+    initializer "railwatch.adopt_final_config", after: :load_config_initializers do
+      Railwatch.adopt_final_config!
+    end
+
     initializer "railwatch.transport_security", after: :load_config_initializers do
       next if Railwatch.config.local? || Railwatch.config.ingest_url_allowed?
 

data/lib/railwatch/reporter.rb

@@ -143,6 +143,32 @@ module Railwatch
       self
     end
 
+    # The reporter can be built before the application's own configuration
+    # has had its say. A rake process invokes its top-level task -- which is
+    # where the command patch starts the execution, and sampling that
+    # execution builds the reporter -- before the task's `:environment`
+    # prerequisite boots Rails and runs config/initializers. A token in the
+    # environment is enough for Railwatch to be enabled that early, so an
+    # embedded app gets a reporter aimed at HTTP, chosen from a config that
+    # had not yet been told the app is embedded. Left alone it stays aimed
+    # there: the memo outlives the configuration that produced it, and every
+    # record from that process goes to the receiver instead of the app's own
+    # database, skipping the export queue and the replay receipts it earns.
+    #
+    # Nothing has been recorded at that point -- starting an execution
+    # decides sampling and pushes nothing -- so deciding again here is free.
+    def adopt_final_config!
+      # The swap forked_transport already makes, for the same reason: the
+      # situation this transport was chosen for is not the situation now.
+      reselected = Railwatch.local_transport if @config.local?
+      @transport = reselected if reselected && reselected.class != @transport.class
+      # Sized from the config as it stood, which was the default one. Safe
+      # only while the buffer is still empty: resizing means a new buffer,
+      # and anything already in the old one would go with it.
+      @buffer = build_buffer if @thread.nil? && @buffer.size.zero?
+      self
+    end
+
     def shutdown
       ensure_process!
       ensure_thread if pending_records? && !@thread&.alive?

data/lib/railwatch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Railwatch
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end

data/lib/railwatch.rb

@@ -72,6 +72,21 @@ module Railwatch
       @reporter ||= Reporter.new(config, transport: local_transport)
     end
 
+    # Called once config/initializers has run, so a reporter built before
+    # that can re-decide what it derived from a configuration that was not
+    # final. Deliberately does not build one: a process that has not
+    # reported anything yet has nothing to correct, and the reporter is
+    # built on first use for a reason.
+    def adopt_final_config!
+      # The redactor snapshots redact_headers when it is built. Today nothing
+      # redacts before this point, so it is built later and already correct --
+      # but an early one would quietly stop hiding the headers an app asked it
+      # to hide, which is not a failure worth leaving to ordering. Dropping the
+      # memo costs a rebuild on next use and nothing else; it holds only caches.
+      @redactor = nil
+      @reporter&.adopt_final_config!
+    end
+
     # Embedded mode: a Puma worker hands its batches to the writer process
     # over the socket; the writer itself, and any process when no socket is
     # configured, writes them straight into SQLite. nil means HTTP.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railwatch
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Cole Robertson