railwatch 0.8.7 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9e80ca205e8ad9435148ba6b185c3de1796f8ffe489f1208876f38e21686181
-  data.tar.gz: '09028109bb2da10a48db010d19f126a5e406bcbe50d2991ebcc303e4c4d74318'
+  metadata.gz: 3cd11714c7a290f5f6717f3b8f239b72b669fce39a2797a59fcb862595925778
+  data.tar.gz: 147d3416d6d047a6c87b8ccdb9d2b67b8e2a6058f881956241f65dff0ea239c5
 SHA512:
-  metadata.gz: 75c81cb580e0948629948f8be59ccaf81e175239e2d268ae7b8cf9f5f6a42073e930881fc2ac5fe7700806c925684f9defd297f47673a2b2470754d688858554
-  data.tar.gz: 8603393804ca3cdd96c5406fb313b1dca1ff7b378c780b7b42765c14d2b76c4e2d0895f8766c0a50fcbe14e0ea5f9ec1381fb7d330737d4ab50b950c76e84e56
+  metadata.gz: 774a7cbf876e5220af985a97a2cc6919ebb91ff9ea7a38e414956b1c0cbf3cedb723cbc470baaa807fa7343295117576df15485923502d855212e83698bee592
+  data.tar.gz: c0d3106cd7c800cf938daf056ce9c279b10e5013af618b39e4e31411517dc578a4e71fd711b5a4158e3b4acdb76964476ca298377f792c0b8f40319ad13c877e

data/AGENTS.md

@@ -102,6 +102,7 @@ expect { Checkout.new(cart).total }.to record_railwatch_span("checkout.total")
 expect { importer.run }.to record_railwatch_exception(ArgumentError)
 expect { importer.run }.not_to record_railwatch_exceptions
 expect { SyncCustomers.run }.to have_railwatch_outgoing_requests(at_most: 1)
+expect { post "/orders", params: }.not_to have_railwatch_http_in_transaction
 
 records = railwatch_capture { get "/widgets" }   # everything the block produced
 ```

data/CHANGELOG.md

@@ -6,6 +6,16 @@
      filled in by the release commit, which is also the only commit that
      touches lib/railwatch/version.rb and Gemfile.lock. See CONTRIBUTING.md. -->
 
+## 0.9.0 (2026-10-08)
+
+- An `outgoing_request` now says whether it was made inside a database
+  transaction (`in_transaction`), like Isolator: the transaction and its
+  locks wait on the other service, and a rollback cannot undo the call. Only
+  transactions the execution began count, so transactional test fixtures do
+  not. New `have_railwatch_http_in_transaction` matcher and
+  `refute_railwatch_http_in_transaction` assertion, and a telemetry migration
+  adding the column to `outgoing_requests`.
+
 ## 0.8.7 (2026-10-06)
 
 - A migration of the railwatch databases waits up to 60 s for SQLite's

data/app/models/railwatch/ingest/mapper.rb

@@ -216,7 +216,7 @@ module Railwatch
         when "mail" then child(Telemetry::Mail, rec, %w[mailer subject to cc bcc attachments delivery_method perform_deliveries duration failed message_id])
         when "broadcast" then child(Telemetry::Broadcast, rec, %w[kind stream channel action bytes duration failed])
         when "notification" then child(Telemetry::Notification, rec, %w[notifier delivery_method channel duration failed])
-        when "outgoing_request" then child(Telemetry::OutgoingRequest, rec, %w[host method url duration status_code request_size response_size error source response_body])
+        when "outgoing_request" then child(Telemetry::OutgoingRequest, rec, %w[host method url duration status_code request_size response_size error source response_body in_transaction])
         when "llm_call" then child(Telemetry::LlmCall, rec, %w[operation provider model response_model tool_name duration status error
           streaming message_count tool_count input_tokens output_tokens cache_read_tokens cache_write_tokens thinking_tokens
           cost_nanos workflow_id workflow_name workflow_step_id workflow_step_name workflow_step_parent_id prompt completion

data/db/railwatch_telemetry_migrate/20261008000000_add_in_transaction_to_outgoing_requests.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# An outgoing HTTP call made while the execution held a database transaction
+# open: the transaction (and on SQLite with BEGIN IMMEDIATE, the writer lock)
+# stays held for the whole round trip. Same meaning as queries.in_transaction.
+class AddInTransactionToOutgoingRequests < ActiveRecord::Migration[8.1]
+  def change
+    add_column :outgoing_requests, :in_transaction, :boolean, default: false
+  end
+end

data/docs/records.md

@@ -500,6 +500,7 @@ never double-recorded.
 | `response_size` | Bytes, from `Content-Length` or body size. |
 | `error` | `"Class: message"`, truncated to 255 chars, if the request raised. |
 | `response_body` | First 4 KiB of the response body, but only when `config.capture_response_body_on_error` is on (off by default) *and* the response was an error. A body that parses as a JSON object is run through the same parameter filter as request params and re-serialized; anything else is stored as it arrived. nil in every other case — including a connection failure, where there is no response (on the Net::HTTP path a body is read only if Net::HTTP already buffered it, so a response being streamed through `read_body` is never consumed; on the Faraday path the body is taken only once a status came back, so an outgoing request payload can never be filed as a response). |
+| `in_transaction` | True when the execution had a database transaction (or savepoint) of its own open for this call, so the transaction and its locks were held for the whole round trip and a rollback cannot undo what the call did. Only transactions the execution began count: one already open when it started, such as a test's transactional fixture, does not. Active Record begins a transaction at its first statement, so a `transaction do` block that has not yet run one is not open. A job performed inline inherits its parent's. The `have_railwatch_http_in_transaction` matcher fails a spec on it. |
 | `source` | App-code call site (Net::HTTP path only). |
 
 ### `llm_call`

data/docs/testing.md

@@ -109,11 +109,26 @@ expect { SyncCustomers.run }.to have_railwatch_outgoing_requests(at_most: 1)
 Same bounds as `have_railwatch_queries`. Failures list the method and URL of
 every request the block made.
 
+### `have_railwatch_http_in_transaction`
+
+```ruby
+expect { post "/orders", params: }.not_to have_railwatch_http_in_transaction
+```
+
+Railwatch's version of [Isolator](https://github.com/palkan/isolator): fails
+when the block makes an outgoing HTTP call while a database transaction it
+opened is still open. The transaction, and every lock it holds, waits on the
+other service, and rolling back cannot undo what the call did. The negated
+failure message lists each such call with the app line that made it. Only
+transactions opened inside the block count, so a suite's transactional
+fixtures never trip it.
+
 ## Minitest assertions
 
 ```ruby
 assert_railwatch_queries(at_most: 5) { OrderSummary.new(order).to_h }
 refute_railwatch_n_plus_one { get widgets_url }
+refute_railwatch_http_in_transaction { post orders_url, params: }
 assert_railwatch_span("checkout.total") { Checkout.new(cart).total }
 ```
 

data/lib/railwatch/execution.rb

@@ -132,6 +132,7 @@ module Railwatch
       @record_limit = @failure_context ? Railwatch.config.failure_context : MAX_RECORDS
       @byte_limit = Railwatch.config.execution_buffer_bytes
       @transaction_statement_counts = Hash.new(0)
+      @open_transactions = 0
       @allocations_start = GC.stat(:total_allocated_objects)
       @gc_time_start = GC.stat(:time) if GC_TIME_SUPPORTED
     end
@@ -306,6 +307,24 @@ module Railwatch
       @transaction_statement_counts.delete(transaction_object_id) || 0
     end
 
+    # Database transactions (and savepoints) this execution has BEGUN and not
+    # yet finished, so an outgoing HTTP call can say whether it held one open.
+    # Only transactions opened during the execution count: a test's
+    # transactional fixture is already open when the execution starts, and
+    # flagging every request spec would make the signal useless. A nested
+    # execution (perform_now inside a request) inherits its parent's.
+    def transaction_opened
+      @open_transactions += 1
+    end
+
+    def transaction_closed
+      @open_transactions -= 1 if @open_transactions.positive?
+    end
+
+    def in_transaction?
+      @open_transactions.positive? || (parent_execution&.in_transaction? || false)
+    end
+
     def duration
       Clock.micros_since(@started_mono)
     end

data/lib/railwatch/faraday.rb

@@ -53,7 +53,8 @@ module Railwatch
                      url: Record.url_without_sensitive_components(url, limit: 2048),
                      duration: Clock.micros_since(start), status_code: env.status.to_i,
                      error: error && "#{error.class}: #{error.message}"[0, 255],
-                     response_body: response_body(env))
+                     response_body: response_body(env),
+                     in_transaction: Railwatch.execution&.in_transaction? || false)
     end
 
     # Faraday threads one Env through the whole stack, and the adapter

data/lib/railwatch/minitest.rb

@@ -32,6 +32,13 @@ module Railwatch
              "detected:#{SpecHelper.n_plus_one_lines(n_plus_ones)}"
     end
 
+    def refute_railwatch_http_in_transaction(&block)
+      offending = railwatch_capture(&block).select { |r| r[:t] == "outgoing_request" && r[:in_transaction] }
+      assert offending.empty?,
+             "Expected no outgoing HTTP requests inside a database transaction, but the block made " \
+             "#{offending.size}:#{SpecHelper.outgoing_lines(offending)}"
+    end
+
     def assert_railwatch_span(name, &block)
       spans = railwatch_capture(&block).select { |r| r[:t] == "span" }
       assert spans.any? { |s| s[:name] == name },

data/lib/railwatch/patches/net_http.rb

@@ -68,6 +68,7 @@ module Railwatch
           response_size: response ? (response["Content-Length"]&.to_i || response.body&.bytesize rescue nil) : nil,
           error: error && "#{error.class}: #{error.message}"[0, 255],
           response_body: response_body(response, error),
+          in_transaction: Railwatch.execution&.in_transaction? || false,
           source: Backtrace.caller_location(skip: 4))
       rescue StandardError => e
         Railwatch.debug { "outgoing request record failed: #{e.message}" }

data/lib/railwatch/rspec.rb

@@ -136,4 +136,27 @@ RSpec::Matchers.define :have_railwatch_outgoing_requests do |bounds|
   end
 end
 
+# Isolator's check: an HTTP call made while a database transaction this
+# block opened is still open holds that transaction (and its locks) for the
+# whole round trip, and a rollback cannot undo what the call did.
+RSpec::Matchers.define :have_railwatch_http_in_transaction do
+  supports_block_expectations
+
+  match do |block|
+    @offending = railwatch_capture(&block).select { |r| r[:t] == "outgoing_request" && r[:in_transaction] }
+    @offending.any?
+  end
+
+  description { "make an outgoing HTTP request inside a database transaction" }
+
+  failure_message do
+    "expected the block to make an outgoing HTTP request inside a database transaction, but it made none"
+  end
+
+  failure_message_when_negated do
+    "expected no outgoing HTTP requests inside a database transaction, but the block made " \
+      "#{@offending.size}:#{Railwatch::SpecHelper.outgoing_lines(@offending)}"
+  end
+end
+
 RSpec.configure { |config| config.include Railwatch::SpecHelper } if defined?(RSpec.configure)

data/lib/railwatch/spec_helper.rb

@@ -115,7 +115,7 @@ module Railwatch
       end
 
       def outgoing_lines(records)
-        lines(records) { |r| "#{r[:method]} #{truncate(r[:url])}" }
+        lines(records) { |r| "#{r[:method]} #{truncate(r[:url])}#{" at #{r[:source]}" if r[:source]}" }
       end
 
       def exception_lines(records)

data/lib/railwatch/subscribers/queries.rb

@@ -148,8 +148,16 @@ module Railwatch
           end
         end
 
+        # Fired when a transaction or savepoint actually sends BEGIN (Active
+        # Record opens them lazily), paired with transaction.active_record
+        # below on commit, rollback, or restart.
+        subscribe_payload("start_transaction.active_record") do |_payload|
+          execution&.transaction_opened
+        end
+
         subscribe("transaction.active_record") do |event|
           exe = execution
+          exe&.transaction_closed
           exe&.count(:transactions)
           p = event.payload
           # Taken (and removed) whether or not a record is built: the

data/lib/railwatch/version.rb

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

data/lib/railwatch/wire_fixtures.json

@@ -538,6 +538,7 @@
     "response_size": 2,
     "error": null,
     "response_body": null,
+    "in_transaction": false,
     "source": "/spec/railwatch/wire_fixtures_spec.rb"
   },
   "storage_op": {

data/lib/railwatch.rb

@@ -389,7 +389,8 @@ module Railwatch
         host = (URI(url.to_s).host rescue nil)
         record(:outgoing_request, group: Record.group_hash(host, method.to_s.upcase),
                timestamp: started_at, host: host, method: method.to_s.upcase,
-               url: url.to_s[0, 2048], duration: Clock.micros_since(start), status_code: result.status.to_i)
+               url: url.to_s[0, 2048], duration: Clock.micros_since(start), status_code: result.status.to_i,
+               in_transaction: execution&.in_transaction? || false)
       end
       result
     end

data/llms.txt

@@ -26,7 +26,7 @@
 - [Embedded mode](docs/embedded.md): the default install — the dashboard inside the app, its two SQLite databases, dashboard authentication, the Puma writer process, maintenance without a job worker, disk reclaim, and optional export to Railwatch Cloud.
 - [Configuration](docs/configuration.md): every configuration option and its `RAILWATCH_*` environment variable, plus the full public facade, redaction, rejection, transport and buffering behaviour, and the rake tasks.
 - [Record types](docs/records.md): every record type the gem ships and every attribute on it, including RubyLLM calls (tokens, cost, finish reason, tool calls, workflows), sourced from the code that builds it.
-- [Testing](docs/testing.md): the RSpec and Minitest matchers (`have_railwatch_queries`, `have_railwatch_n_plus_one`, `record_railwatch_span`, `record_railwatch_exception`, `have_railwatch_outgoing_requests`) and a CI performance-gate recipe.
+- [Testing](docs/testing.md): the RSpec and Minitest matchers (`have_railwatch_queries`, `have_railwatch_n_plus_one`, `record_railwatch_span`, `record_railwatch_exception`, `have_railwatch_outgoing_requests`, `have_railwatch_http_in_transaction`) and a CI performance-gate recipe.
 - [Production source maps](docs/source-maps.md): hidden Vite maps, private upload before publishing assets, safe opt-in deletion, resolved browser stacks and default issue grouping.
 - [AI assistants and MCP](docs/ai-and-mcp.md): Railwatch Cloud's MCP endpoint, how to get a token, paste-ready client configuration for Claude Code, Claude Desktop, Cursor, VS Code, and Zed, and every tool, prompt, and resource the server exposes.
 - [Replacing Sentry](docs/replacing-sentry.md): a step-by-step migration — removing the gems, porting each option, rewriting each call site, breadcrumbs, spans, profiling, attachments, `before_send`, fingerprints, and release health.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railwatch
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.9.0
 platform: ruby
 authors:
 - Cole Robertson
@@ -406,6 +406,7 @@ files:
 - db/railwatch_telemetry_migrate/20260922000000_add_covering_indexes_for_dashboard_aggregates.rb
 - db/railwatch_telemetry_migrate/20260923000000_add_people_index.rb
 - db/railwatch_telemetry_migrate/20260925000000_add_tenant_summary_index.rb
+- db/railwatch_telemetry_migrate/20261008000000_add_in_transaction_to_outgoing_requests.rb
 - docs/ai-and-mcp.md
 - docs/configuration.md
 - docs/embedded.md