standard_ledger 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f6aa5d56ba73fe170790d016b50f00aec95f563346a08c36f8823d05fbddd98
-  data.tar.gz: dc1ef4c96e69b6a8d4832ce1f80dc6a979d63dc25ff059ed77794b829f414e7f
+  metadata.gz: ddedb70c2937f7108178cce27f7150b58c39c5aadfdab2561947b626bd345d9c
+  data.tar.gz: be910d616703d17691bdc6f184247b5efe78bc959006c24f43ee4bfbeb5df263
 SHA512:
-  metadata.gz: 54f927af7564ee7e9319a2fd87358a86e91ab55c7d3fea872dc9f821efc40cde0cd31b55cdf4b90e7bfb138bb501a7e9888358a2645f27c662058ba2fd2ef869
-  data.tar.gz: 108ce4c242c054512e6f3f173cf683dc9f71ee08882ed82dd505be092af6fb08f7b97b635aa5685ed5c08f7257e6ad285d327a2b4a9bd1f07c2ee1bcfcda19d2
+  metadata.gz: 1bd764a4596fb6468f5ffa9b2d51e39a5203f6135bbdbde6cacec33091aa0e86cedaa1393392f417378a720f6e26987438c8a46fc80028204ecf0250ed3a7c49
+  data.tar.gz: 829aad11a875317df036555736281f0ca6d961045bd3a5b2dd6090592ce0aabce772583b34d7fd403c69a4f331bb11f46e6a9622ccc62f510fb0574dea8bd85a

data/CHANGELOG.md

@@ -6,6 +6,51 @@ project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-09-24
+
+The Phase 4 release. The removals the cleanup plan scheduled for it (the
+`scheduler` config, `PartialFailure`, and the engine's no-op initializer)
+already shipped in 0.6.0, and 0.6.0 deprecated nothing, so this release only
+changes how `refresh!` reports failures. It is a minor bump because hosts that
+report refresh failures themselves should delete that code.
+
+### Changed
+- **`StandardLedger.refresh!` reports SQL failures through `Rails.error`.**
+  When the `REFRESH` statement raises, the gem emits `projection.failed` (as
+  before), then calls `Rails.error.report(error, handled: false,
+  severity: :error, context: { view:, concurrently: }, source:
+  "standard_ledger")`, then re-raises. It falls back to
+  `ActiveSupport.error_reporter` outside Rails. A reporter that raises is
+  ignored, so it can never mask the refresh error. Input errors raised before
+  any SQL runs are not reported (`ArgumentError`, `RefreshInsideTransaction`).
+  **No double reports:** Rails' `ErrorReporter` flags a reported exception
+  and skips it when the same object is reported again. That covers a host
+  rescue that reports and re-raises, and the executor wrapping the job.
+- The `:auto` catalog-probe failure report (handled, `:warning`) now goes
+  through the same `StandardLedger.report_error` helper (`@api private`).
+  Its payload is unchanged.
+
+### Upgrade notes (0.6.x → 0.7.0)
+1. Bump to `gem "standard_ledger", "~> 0.7"`. Nothing was removed, so no code
+   change is required.
+2. **Optional cleanup:** delete any report-and-re-raise rescue around
+   `refresh!`. Grepped `origin/main` of all consumers on 2026-09-24:
+   - luminality-web `app/jobs/refresh_admin_dashboard_metrics_job.rb:20-27`
+     (`rescue StandardError => e; Rails.error.report(e, handled: true,
+     context: { view: "admin_dashboard_metrics" }); raise`). Delete the rescue
+     and fix the header comment ("…does not report").
+   - sidekick-web `app/jobs/refresh_materialized_views_job.rb` has no rescue.
+     Its refresh failures are now reported by the gem, with view context,
+     before the job runner sees them.
+   - jumpdrive-web and fundbright-web don't call `refresh!`.
+3. **Expect a different Sentry grouping context** for refresh failures:
+   `source: "standard_ledger"` and `context.view`. The error class and
+   backtrace are unchanged.
+4. Sorbet apps: regenerate the gem RBI (`bin/tapioca gem standard_ledger`).
+   jumpdrive-web's `control-plane/config/initializers/standard_ledger.rb:12-13`
+   still mentions the removed `scheduler`/`default_async_*` config in a
+   comment. The comment is historical and harmless.
+
 ## [0.6.0] - 2026-09-24
 
 A breaking release. The declarative projection engine is removed, and the gem

data/README.md

@@ -129,14 +129,21 @@ with `concurrently: false` can pass `concurrently: :auto` instead.
 
 `refresh!` returns a success Result with
 `projections[:refreshed] = [{ view:, concurrently: }]` (the concurrency mode
-that was actually used). If the SQL fails, it emits `projection.failed` and
-re-raises so your job runner can retry. View names must be bare or
-`schema.view` identifiers. Anything else raises `ArgumentError`.
+that was actually used). If the SQL fails, it emits `projection.failed`,
+reports the error to `Rails.error` (`handled: false`, `severity: :error`,
+`context: { view:, concurrently: }`, `source: "standard_ledger"`), and
+re-raises so your job runner can retry. Since 0.7 you don't need a
+report-and-re-raise rescue around `refresh!` in your job. An existing one is
+harmless: Rails skips an exception object it has already reported, so the
+failure is reported once. Input errors (an invalid view name, an unknown
+`concurrently:`, `RefreshInsideTransaction`) are raised before any SQL runs
+and are not reported by the gem. View names must be bare or `schema.view`
+identifiers. Anything else raises `ArgumentError`.
 
 ## Installation
 
 ```ruby
-gem "standard_ledger", "~> 0.6"
+gem "standard_ledger", "~> 0.7"
 ```
 
 (Don't reintroduce a `git:` reference. It makes a bare `bundle install` a

data/lib/standard_ledger/matview.rb

@@ -44,8 +44,15 @@ module StandardLedger
       end
 
       # Issue `REFRESH MATERIALIZED VIEW [CONCURRENTLY] <view_name>` and emit
-      # `<prefix>.projection.refreshed` on success, or
-      # `<prefix>.projection.failed` before re-raising on SQL failure.
+      # `<prefix>.projection.refreshed` on success. On SQL failure, emit
+      # `<prefix>.projection.failed`, report the error through `Rails.error`
+      # (`handled: false`, `severity: :error`) and re-raise.
+      #
+      # Reporting before the re-raise means host jobs no longer need their
+      # own report-and-re-raise rescue. It cannot double-report: Rails'
+      # ErrorReporter flags a reported exception and skips it when the same
+      # object is reported again (by a host rescue, or by the executor that
+      # wraps the job).
       #
       # The view name is validated against a SQL-identifier regex at the
       # boundary as defence in depth — a careless host could pass through a
@@ -72,6 +79,10 @@ module StandardLedger
             "#{prefix}.projection.failed",
             view: view_name.to_s, concurrently: concurrently, mode: :matview, error: e
           )
+          StandardLedger.report_error(
+            e, handled: false, severity: :error,
+            context: { view: view_name.to_s, concurrently: concurrently }
+          )
           raise
         end
 
@@ -140,23 +151,13 @@ module StandardLedger
 
         boolean(row["populated"]) && boolean(row["unique_index"])
       rescue StandardError => e
-        report_error(e, view: view_name.to_s)
+        StandardLedger.report_error(e, handled: true, severity: :warning, context: { view: view_name.to_s })
         false
       end
 
       def boolean(value)
         ActiveModel::Type::Boolean.new.cast(value) == true
       end
-
-      def report_error(error, context)
-        reporter =
-          if defined?(::Rails) && ::Rails.respond_to?(:error)
-            ::Rails.error
-          elsif ActiveSupport.respond_to?(:error_reporter)
-            ActiveSupport.error_reporter
-          end
-        reporter&.report(error, handled: true, severity: :warning, context: context, source: "standard_ledger")
-      end
     end
   end
 end

data/lib/standard_ledger/version.rb

@@ -1,3 +1,3 @@
 module StandardLedger
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/standard_ledger.rb

@@ -92,9 +92,16 @@ module StandardLedger
 
     # Refresh a host-owned materialized view. Issues
     # `REFRESH MATERIALIZED VIEW [CONCURRENTLY] <view_name>` against the
-    # active connection and emits `<prefix>.projection.refreshed` on success
-    # (or `<prefix>.projection.failed` on raise, before re-raising — the
-    # host's job runner needs to see the failure to drive its retry path).
+    # active connection and emits `<prefix>.projection.refreshed` on success.
+    # When the refresh SQL raises, it emits `<prefix>.projection.failed`,
+    # reports the error through `Rails.error` (`handled: false`,
+    # `severity: :error`, `context: { view:, concurrently: }`,
+    # `source: "standard_ledger"`) and re-raises, so the host's job runner
+    # still drives its retry path. Hosts don't need their own
+    # report-and-re-raise; Rails skips an exception it has already reported,
+    # so an existing one is harmless. Argument errors and
+    # `RefreshInsideTransaction` are programming errors raised before any
+    # SQL runs; they are not reported by the gem.
     #
     # @example scheduled job refreshing a list of views
     #   VIEWS.each { |view| StandardLedger.refresh!(view, concurrently: :auto) }
@@ -130,6 +137,23 @@ module StandardLedger
       )
     end
 
+    # Report +error+ through `Rails.error` (or `ActiveSupport.error_reporter`
+    # outside Rails) with `source: "standard_ledger"`. A reporter failure is
+    # swallowed so it can never mask the error being reported.
+    #
+    # @api private
+    def report_error(error, handled:, severity:, context:)
+      reporter =
+        if defined?(::Rails) && ::Rails.respond_to?(:error)
+          ::Rails.error
+        elsif ActiveSupport.respond_to?(:error_reporter)
+          ActiveSupport.error_reporter
+        end
+      reporter&.report(error, handled: handled, severity: severity, context: context, source: "standard_ledger")
+    rescue StandardError
+      nil
+    end
+
     private
 
     # Resolve the kind column name for an entry class. Falls back to `:kind`

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: standard_ledger
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Jaryl Sim