source_monitor 0.6.0 → 0.7.1

data/.vbw-planning/phases/02-test-performance/PLAN-03.md

@@ -0,0 +1,154 @@
+---
+phase: "02"
+plan: "03"
+title: "Adopt before_all in DB-Heavy Test Files"
+wave: 1
+depends_on: []
+must_haves:
+  - "REQ-PERF-05: Top DB-heavy test files converted from per-test setup to setup_once/before_all"
+  - "sources_index_metrics_test.rb converted to setup_once (17 tests, shared read-only fixtures)"
+  - "Additional eligible files converted where safe (read-only shared data)"
+  - "Only read-only test data shared via setup_once (tests that mutate data keep per-test setup)"
+  - "All converted tests pass individually with PARALLEL_WORKERS=1"
+  - "Full test suite passes with no isolation regressions"
+  - "RuboCop zero offenses on modified files"
+skills_used: []
+---
+
+# Plan 03: Adopt before_all in DB-Heavy Test Files
+
+## Objective
+
+Convert eligible DB-heavy test files from per-test `setup` to `setup_once`/`before_all` for shared fixture creation. The `setup_once` helper (alias for `before_all`) is already wired up in `test/test_prof.rb` but only used in 1 of 54 eligible files. This saves ~3-5s by eliminating redundant database INSERT/DELETE cycles.
+
+## Context
+
+- `@` `test/test_prof.rb` -- `setup_once` (alias for `before_all`) already configured and included in `ActiveSupport::TestCase`
+- `@` `test/lib/source_monitor/logs/query_test.rb` -- only existing user of `setup_once` (reference pattern)
+- `@` `test/lib/source_monitor/analytics/sources_index_metrics_test.rb` -- 17 tests, shared read-only fixtures. **PRIMARY candidate: creates 3 sources + 3 items in setup, all tests only query this data.**
+- `@` `test/lib/source_monitor/analytics/source_activity_rates_test.rb` -- 1 test, uses `clean_source_monitor_tables!`
+- `@` `test/lib/source_monitor/analytics/source_fetch_interval_distribution_test.rb` -- 1 test, uses `clean_source_monitor_tables!`
+- `@` `test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb` -- 1 test, uses `clean_source_monitor_tables!`
+
+**Safety analysis performed:**
+- `sources_index_metrics_test.rb`: SAFE. All 17 tests construct `SourcesIndexMetrics.new(...)` and call read-only query methods. No test creates, updates, or deletes records.
+- `source_activity_rates_test.rb`: SAFE but minimal benefit (1 test, setup runs once either way).
+- `source_fetch_interval_distribution_test.rb`: SAFE but minimal benefit (1 test).
+- `upcoming_fetch_schedule_test.rb`: SAFE but minimal benefit (1 test).
+- `dashboard/queries_test.rb`: NOT SAFE. Each test creates its own sources and checks specific counts. Shared state would cause pollution.
+- `health/source_health_monitor_test.rb`: NOT SAFE. Tests mutate `@source` via `SourceHealthMonitor.call`.
+- `items/item_creator_test.rb`: NOT SAFE. Tests create items on shared source and check counts.
+
+**Rationale:** `before_all` wraps fixture creation in a SAVEPOINT, shared across all tests in the class. After all tests run, the savepoint rolls back. This only works when tests are read-only on the shared data. The `sources_index_metrics_test.rb` is the highest-value candidate with 17 read-only tests sharing the same 3 sources + 3 items.
+
+## Tasks
+
+### Task 1: Convert sources_index_metrics_test.rb to setup_once (PRIMARY)
+
+This is the highest-impact conversion. Convert `test/lib/source_monitor/analytics/sources_index_metrics_test.rb`:
+
+Replace:
+```ruby
+setup do
+  clean_source_monitor_tables!
+  travel_to Time.current.change(usec: 0)
+  @fast_source = create_source!(name: "Fast", fetch_interval_minutes: 30)
+  # ... fixture creation
+end
+```
+
+With:
+```ruby
+setup_once do
+  clean_source_monitor_tables!
+  @fast_source = create_source!(name: "Fast", fetch_interval_minutes: 30)
+  # ... same fixture creation, but now runs once for all 17 tests
+end
+```
+
+**Important:** The `travel_to` call must stay in a regular `setup` block because `travel_to` affects the thread-local time for each test independently:
+```ruby
+setup_once do
+  clean_source_monitor_tables!
+  # fixture creation here
+end
+
+setup do
+  travel_to Time.current.change(usec: 0)
+end
+
+teardown do
+  travel_back
+end
+```
+
+Wait -- `travel_to` inside `setup_once` would freeze time for the SAVEPOINT transaction but tests need consistent time for assertions. Actually, the fixtures are created with relative timestamps (`1.day.ago`, `2.days.ago`) which depend on `Time.current`. If `travel_to` is in `setup_once`, the timestamps are fixed at creation time, which is fine since tests read them as-is. But `travel_back` in teardown would only run once after all tests, and the `travel_to` in `setup_once` persists through all tests.
+
+Safest approach: Move `travel_to` into `setup_once` and remove the teardown's `travel_back` (before_all handles cleanup). Add a regular `setup` with `travel_to` at the same frozen time to ensure each test sees consistent time.
+
+Actually, the simplest safe approach: keep `travel_to` and `travel_back` in regular `setup`/`teardown`, and only put the DB operations in `setup_once`. The fixtures use relative timestamps (`1.day.ago`) which will be slightly different each test, but since the tests only compare relative values (bucket labels, activity rates), this is fine.
+
+### Task 2: Convert single-test analytics files to setup_once
+
+Convert these 3 files for consistency (minimal performance benefit but establishes the pattern):
+
+1. **`test/lib/source_monitor/analytics/source_activity_rates_test.rb`** -- Replace `setup { clean_source_monitor_tables! }` with `setup_once { clean_source_monitor_tables! }`
+2. **`test/lib/source_monitor/analytics/source_fetch_interval_distribution_test.rb`** -- Same pattern
+3. **`test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb`** -- Same pattern
+
+For single-test classes, `setup` and `setup_once` are functionally identical, so this is a no-op in terms of performance but normalizes the codebase to use the `setup_once` pattern for table cleaning.
+
+### Task 3: Verify all converted files individually
+
+Run each converted file with PARALLEL_WORKERS=1 to confirm no regressions:
+```bash
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/analytics/sources_index_metrics_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/analytics/source_activity_rates_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/analytics/source_fetch_interval_distribution_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb
+```
+
+If any file fails due to test isolation issues, revert it to per-test setup and document why.
+
+### Task 4: Full suite verification and lint
+
+```bash
+# Full suite (all 1031+ tests pass)
+bin/rails test
+
+# Lint all modified files
+bin/rubocop test/lib/source_monitor/analytics/ test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb
+```
+
+Ensure total test count remains 1031+ and no failures occur.
+
+## Files
+
+| Action | Path |
+|--------|------|
+| MODIFY | `test/lib/source_monitor/analytics/sources_index_metrics_test.rb` |
+| MODIFY | `test/lib/source_monitor/analytics/source_activity_rates_test.rb` |
+| MODIFY | `test/lib/source_monitor/analytics/source_fetch_interval_distribution_test.rb` |
+| MODIFY | `test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb` |
+
+## Verification
+
+```bash
+# Individual file runs
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/analytics/sources_index_metrics_test.rb
+PARALLEL_WORKERS=1 bin/rails test test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb
+
+# Full suite (all 1031+ tests pass)
+bin/rails test
+
+# Lint
+bin/rubocop test/lib/source_monitor/analytics/ test/lib/source_monitor/dashboard/upcoming_fetch_schedule_test.rb
+```
+
+## Success Criteria
+
+- `grep -r "setup_once" test/lib/source_monitor/` shows 5+ files (up from 1)
+- `sources_index_metrics_test.rb` uses `setup_once` for fixture creation
+- All 1031+ tests pass in full suite
+- No test isolation regressions in parallel runs
+- Each converted file passes individually with PARALLEL_WORKERS=1

data/.vbw-planning/phases/02-test-performance/PLAN-04-SUMMARY.md

@@ -0,0 +1,28 @@
+---
+phase: 2
+plan: 4
+status: complete
+---
+# Plan 04 Summary: Switch Default Parallelism to Threads
+
+## Tasks Completed
+- [x] Task 1: Switch parallelize to always use `with: :threads` (not just coverage mode)
+- [x] Task 2: Add thread-safety comment to reset_configuration! setup block
+- [x] Task 3: Verify single-file runs work without PARALLEL_WORKERS=1 (3 files tested, all pass)
+- [x] Task 4: Full suite verification (1033 tests, 0 failures, 2 consecutive runs, 0 flaky)
+
+## Commits
+- eceb06d: perf(test): switch default parallelism from forks to threads
+
+## Files Modified
+- test/test_helper.rb (modified)
+
+## What Was Built
+- Unified parallelism to always use `with: :threads` instead of fork-based (forks only used in coverage mode previously)
+- Worker count logic preserved: COVERAGE=1 forces 1 worker, otherwise respects SOURCE_MONITOR_TEST_WORKERS env var or defaults to :number_of_processors
+- PG fork segfault on single-file runs eliminated — verified with feed_fetcher_success_test.rb, source_test.rb, and sources_controller_test.rb all passing without PARALLEL_WORKERS=1
+- Added thread-safety comment explaining why reset_configuration! is safe under thread parallelism
+- Note: TestProf emits `before_all is not implemented for parallalization with threads` warning — cosmetic only, before_all works correctly since single-file runs stay below parallelization threshold and full suite distributes by class
+
+## Deviations
+- None

data/.vbw-planning/phases/02-test-performance/PLAN-04.md

@@ -0,0 +1,133 @@
+---
+phase: "02"
+plan: "04"
+title: "Switch Default Parallelism to Threads"
+wave: 2
+depends_on: ["PLAN-01"]
+must_haves:
+  - "REQ-PERF-04: Default parallelism switched from forks to threads"
+  - "test_helper.rb parallelize call uses 'with: :threads' for all modes"
+  - "Thread safety verified for reset_configuration! (no data races)"
+  - "All 1031+ tests pass with thread-based parallelism"
+  - "PG fork segfault on single-file runs eliminated"
+  - "PARALLEL_WORKERS env var still respected"
+  - "RuboCop zero offenses on modified files"
+skills_used: []
+---
+
+# Plan 04: Switch Default Parallelism to Threads
+
+## Objective
+
+Switch the default test parallelism from fork-based to thread-based. This eliminates the PG fork segfault that forces `PARALLEL_WORKERS=1` on single-file runs, and enables the FeedFetcherTest split (Plan 01) to actually parallelize across workers. Thread-based parallelism is already proven working in coverage mode (`COVERAGE=1`).
+
+## Context
+
+- `@` `test/test_helper.rb` -- current parallelism configuration (forks by default, threads only for coverage)
+- `@` `.vbw-planning/phases/02-test-performance/02-RESEARCH.md` -- research confirming thread parallelism works in coverage mode
+- `@` `test/test_prof.rb` -- TestProf setup (thread-compatible)
+
+**Rationale:** The current code uses `parallelize(workers: worker_count)` which defaults to fork-based parallelism. This causes PG segfaults on single-file runs and prevents the FeedFetcherTest split from distributing across workers (since forks copy the process and the PG connection). Thread-based parallelism is already proven (used with COVERAGE=1) and avoids these issues.
+
+**Dependency on Plan 01:** Plan 01 splits FeedFetcherTest into 6+ classes. Without the split, thread parallelism still cannot distribute the 71-test monolith across workers. The split must complete first for the parallelism switch to realize its full benefit.
+
+**Risk: Thread safety of `reset_configuration!`** -- The global `setup` block calls `SourceMonitor.reset_configuration!` before every test. With threads, multiple tests may call this simultaneously. Since `reset_configuration!` replaces the entire `@configuration` instance, and each test reads config after setup, this is safe as long as no test modifies config mid-test while another test is reading it. The research confirmed this is pure Ruby assignment (microseconds). If any flaky failures appear, we add a `Mutex` around the reset.
+
+## Tasks
+
+### Task 1: Switch parallelize to threads
+
+In `test/test_helper.rb`, replace the parallelism block:
+
+```ruby
+# BEFORE:
+if ENV["COVERAGE"]
+  parallelize(workers: 1, with: :threads)
+else
+  worker_count = ENV.fetch("SOURCE_MONITOR_TEST_WORKERS", :number_of_processors)
+  worker_count = worker_count.to_i if worker_count.is_a?(String) && !worker_count.empty?
+  worker_count = :number_of_processors if worker_count.respond_to?(:zero?) && worker_count.zero?
+  parallelize(workers: worker_count)
+end
+```
+
+```ruby
+# AFTER:
+worker_count = if ENV["COVERAGE"]
+  1
+else
+  count = ENV.fetch("SOURCE_MONITOR_TEST_WORKERS", :number_of_processors)
+  count = count.to_i if count.is_a?(String) && !count.empty?
+  count = :number_of_processors if count.respond_to?(:zero?) && count.zero?
+  count
+end
+parallelize(workers: worker_count, with: :threads)
+```
+
+Key change: Always use `with: :threads` (not just for coverage). Worker count logic stays the same.
+
+### Task 2: Add thread-safety comment to reset_configuration
+
+Add a comment in the `setup` block explaining thread safety:
+
+```ruby
+setup do
+  # Thread-safe: reset_configuration! replaces @configuration atomically.
+  # Each test gets a fresh config object. No concurrent mutation risk since
+  # tests read config only after their own setup completes.
+  SourceMonitor.reset_configuration!
+end
+```
+
+### Task 3: Verify single-file runs work without PARALLEL_WORKERS=1
+
+The main benefit of thread-based parallelism: single-file runs no longer segfault.
+
+```bash
+# These should now work WITHOUT PARALLEL_WORKERS=1
+bin/rails test test/lib/source_monitor/fetching/feed_fetcher_success_test.rb
+bin/rails test test/models/source_monitor/source_test.rb
+bin/rails test test/controllers/source_monitor/sources_controller_test.rb
+```
+
+### Task 4: Full suite verification
+
+```bash
+# Full suite with thread parallelism
+bin/rails test
+
+# Verify worker count is respected
+SOURCE_MONITOR_TEST_WORKERS=4 bin/rails test
+
+# Lint
+bin/rubocop test/test_helper.rb
+```
+
+Ensure all 1031+ tests pass with zero failures. Watch for flaky tests that might indicate thread-safety issues. If any test fails intermittently, check if it modifies global state (module-level variables, class variables, or singletons) and fix the isolation.
+
+## Files
+
+| Action | Path |
+|--------|------|
+| MODIFY | `test/test_helper.rb` |
+
+## Verification
+
+```bash
+# Single-file run (no PARALLEL_WORKERS=1 needed)
+bin/rails test test/models/source_monitor/source_test.rb
+
+# Full suite
+bin/rails test
+
+# Lint
+bin/rubocop test/test_helper.rb
+```
+
+## Success Criteria
+
+- `grep "with: :threads" test/test_helper.rb` shows the threads configuration
+- `bin/rails test` passes all 1031+ tests
+- Single-file runs work without PARALLEL_WORKERS=1 workaround
+- No flaky test failures in 2 consecutive full suite runs
+- Full suite completes in <70s locally (down from 133s)

data/CHANGELOG.md

@@ -15,6 +15,41 @@ All notable changes to this project are documented below. The format follows [Ke
 
 - No unreleased changes yet.
 
+## [0.7.1] - 2026-02-18
+
+### Changed
+
+- **Test suite 60% faster (118s → 46s).** Disabled Faraday retry middleware in tests — WebMock-stubbed timeout errors triggered 4 retries with exponential backoff (7.5s of real sleep per test), consuming 73% of total runtime across 11 FeedFetcher tests.
+- Split monolithic FeedFetcherTest (71 tests, 84.8s) into 6 concern-based test classes for better parallelization and maintainability.
+- Switched default test parallelism from fork-based to thread-based, eliminating PG segfault on single-file runs.
+- Reduced test log IO by setting test log level to `:warn` (was `:debug`, generating 95MB of output).
+- Adopted `setup_once`/`before_all` in 5 DB-heavy analytics/dashboard test files.
+- Added `test:fast` rake task to exclude integration and system tests during development.
+
+### Fixed
+
+- Suppressed spurious TestProf "before_all is not implemented for threads" warning by loading TestProf after `parallelize` call.
+
+### Testing
+
+- 1,033 tests, 3,302 assertions, 0 failures.
+- RuboCop: 0 offenses.
+- Brakeman: 0 warnings.
+
+## [0.7.0] - 2026-02-18
+
+### Fixed
+
+- **False "updated" counts on unchanged feed items.** ItemCreator now checks for significant attribute changes before saving. Items with no real changes return a new `:unchanged` status instead of `:updated`, eliminating unnecessary database writes and misleading dashboard statistics.
+- **Redundant entry processing on unchanged feeds.** When a feed's body SHA-256 signature matches the previous fetch, entry processing is now skipped entirely (like the existing 304 Not Modified path), avoiding unnecessary parsing, DB lookups, and saves.
+- **Adaptive interval not backing off for stable feeds.** The `content_changed` signal for adaptive fetch scheduling now uses an item-level content hash (sorted entry IDs) instead of the raw XML body hash. This prevents cosmetic feed changes (e.g., `<lastBuildDate>` updates) from defeating interval backoff, allowing stable feeds to correctly increase their fetch interval.
+
+### Testing
+
+- 1,031 tests, 3,300 assertions, 0 failures.
+- RuboCop: 0 offenses.
+- Brakeman: 0 warnings.
+
 ## [0.6.0] - 2026-02-17
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    source_monitor (0.6.0)
+    source_monitor (0.7.1)
       cssbundling-rails (~> 1.4)
       faraday (~> 2.9)
       faraday-follow_redirects (~> 0.4)

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.1

data/lib/source_monitor/fetching/feed_fetcher/entry_processor.rb

@@ -14,6 +14,7 @@ module SourceMonitor
           return FeedFetcher::EntryProcessingResult.new(
             created: 0,
             updated: 0,
+            unchanged: 0,
             failed: 0,
             items: [],
             errors: [],
@@ -23,6 +24,7 @@ module SourceMonitor
 
           created = 0
           updated = 0
+          unchanged = 0
           failed = 0
           items = []
           created_items = []
@@ -39,6 +41,8 @@ module SourceMonitor
                 created_items << result.item
                 SourceMonitor::Events.after_item_created(item: result.item, source:, entry:, result: result)
                 enqueue_image_download(result.item)
+              elsif result.unchanged?
+                unchanged += 1
               else
                 updated += 1
                 updated_items << result.item
@@ -52,6 +56,7 @@ module SourceMonitor
           FeedFetcher::EntryProcessingResult.new(
             created:,
             updated:,
+            unchanged:,
             failed:,
             items:,
             errors: errors.compact,

data/lib/source_monitor/fetching/feed_fetcher/source_updater.rb

@@ -11,7 +11,7 @@ module SourceMonitor
           @adaptive_interval = adaptive_interval
         end
 
-        def update_source_for_success(response, duration_ms, feed, feed_signature)
+        def update_source_for_success(response, duration_ms, feed, feed_signature, content_changed: nil, entries_digest: nil)
           attributes = {
             last_fetched_at: Time.current,
             last_fetch_duration_ms: duration_ms,
@@ -31,8 +31,10 @@ module SourceMonitor
             attributes[:last_modified] = parsed_time if parsed_time
           end
 
-          adaptive_interval.apply_adaptive_interval!(attributes, content_changed: feed_signature_changed?(feed_signature))
-          attributes[:metadata] = updated_metadata(feed_signature: feed_signature)
+          # Use explicit content_changed if provided, otherwise fall back to feed signature comparison
+          changed = content_changed.nil? ? feed_signature_changed?(feed_signature) : content_changed
+          adaptive_interval.apply_adaptive_interval!(attributes, content_changed: changed)
+          attributes[:metadata] = updated_metadata(feed_signature: feed_signature, entries_digest: entries_digest)
           reset_retry_state!(attributes)
           source.update!(attributes)
         end
@@ -111,10 +113,11 @@ module SourceMonitor
           (source.metadata || {}).fetch("last_feed_signature", nil) != feed_signature
         end
 
-        def updated_metadata(feed_signature: nil)
+        def updated_metadata(feed_signature: nil, entries_digest: nil)
           metadata = (source.metadata || {}).dup
           metadata.delete("dynamic_fetch_interval_seconds")
           metadata["last_feed_signature"] = feed_signature if feed_signature.present?
+          metadata["last_entries_digest"] = entries_digest if entries_digest.present?
           metadata
         end
 

data/lib/source_monitor/fetching/feed_fetcher.rb

@@ -17,6 +17,7 @@ module SourceMonitor
       EntryProcessingResult = Struct.new(
         :created,
         :updated,
+        :unchanged,
         :failed,
         :items,
         :errors,
@@ -123,11 +124,28 @@ module SourceMonitor
       def handle_success(response, started_at, instrumentation_payload)
         duration_ms = source_updater.elapsed_ms(started_at)
         body = response.body
+        feed_body_signature = body_digest(body)
         feed = parse_feed(body, response)
-        processing = entry_processor.process_feed_entries(feed)
 
-        feed_body_signature = body_digest(body)
-        source_updater.update_source_for_success(response, duration_ms, feed, feed_body_signature)
+        if source_updater.feed_signature_changed?(feed_body_signature)
+          processing = entry_processor.process_feed_entries(feed)
+          content_changed = entries_digest_changed?(feed)
+        else
+          processing = EntryProcessingResult.new(
+            created: 0,
+            updated: 0,
+            unchanged: 0,
+            failed: 0,
+            items: [],
+            errors: [],
+            created_items: [],
+            updated_items: []
+          )
+          content_changed = false
+        end
+
+        feed_entries_digest = entries_digest(feed)
+        source_updater.update_source_for_success(response, duration_ms, feed, feed_body_signature, content_changed: content_changed, entries_digest: feed_entries_digest)
         source_updater.create_fetch_log(
           response: response,
           duration_ms: duration_ms,
@@ -180,6 +198,7 @@ module SourceMonitor
           item_processing: EntryProcessingResult.new(
             created: 0,
             updated: 0,
+            unchanged: 0,
             failed: 0,
             items: [],
             errors: [],
@@ -230,6 +249,7 @@ module SourceMonitor
           item_processing: EntryProcessingResult.new(
             created: 0,
             updated: 0,
+            unchanged: 0,
             failed: 0,
             items: [],
             errors: [],
@@ -277,6 +297,32 @@ module SourceMonitor
         Digest::SHA256.hexdigest(body)
       end
 
+      def entries_digest(feed)
+        return if feed.nil? || !feed.respond_to?(:entries)
+
+        ids = Array(feed.entries).map do |entry|
+          if entry.respond_to?(:entry_id) && entry.entry_id.present?
+            entry.entry_id
+          elsif entry.respond_to?(:url) && entry.url.present?
+            entry.url
+          elsif entry.respond_to?(:title) && entry.title.present?
+            entry.title
+          end
+        end.compact.sort
+
+        return if ids.empty?
+
+        Digest::SHA256.hexdigest(ids.join("\0"))
+      end
+
+      def entries_digest_changed?(feed)
+        digest = entries_digest(feed)
+        return false if digest.nil?
+
+        stored = (source.metadata || {}).fetch("last_entries_digest", nil)
+        stored != digest
+      end
+
       def adaptive_interval
         @adaptive_interval ||= AdaptiveInterval.new(source: source, jitter_proc: jitter_proc)
       end

data/lib/source_monitor/items/item_creator.rb

@@ -21,6 +21,10 @@ module SourceMonitor
         def updated?
           status == :updated
         end
+
+        def unchanged?
+          status == :unchanged
+        end
       end
 
       FINGERPRINT_SEPARATOR = "\u0000".freeze
@@ -46,8 +50,15 @@ module SourceMonitor
         existing_item, matched_by = existing_item_for(attributes, raw_guid_present: raw_guid.present?)
 
         if existing_item
-          updated_item = update_existing_item(existing_item, attributes, matched_by)
-          return Result.new(item: updated_item, status: :updated, matched_by: matched_by)
+          apply_attributes(existing_item, attributes)
+          instrument_duplicate(existing_item, matched_by)
+          if significant_changes?(existing_item)
+            existing_item.save!
+            return Result.new(item: existing_item, status: :updated, matched_by: matched_by)
+          else
+            existing_item.reload if existing_item.changed?
+            return Result.new(item: existing_item, status: :unchanged, matched_by: matched_by)
+          end
         end
 
         create_new_item(attributes, raw_guid_present: raw_guid.present?)
@@ -100,7 +111,7 @@ module SourceMonitor
 
       def update_existing_item(existing_item, attributes, matched_by)
         apply_attributes(existing_item, attributes)
-        existing_item.save!
+        existing_item.save! if significant_changes?(existing_item)
         instrument_duplicate(existing_item, matched_by)
         existing_item
       end
@@ -117,8 +128,15 @@ module SourceMonitor
       def handle_concurrent_duplicate(attributes, raw_guid_present:)
         matched_by = raw_guid_present ? :guid : :fingerprint
         existing = find_conflicting_item(attributes, matched_by)
-        updated = update_existing_item(existing, attributes, matched_by)
-        Result.new(item: updated, status: :updated, matched_by: matched_by)
+        apply_attributes(existing, attributes)
+        instrument_duplicate(existing, matched_by)
+        if significant_changes?(existing)
+          existing.save!
+          Result.new(item: existing, status: :updated, matched_by: matched_by)
+        else
+          existing.reload if existing.changed?
+          Result.new(item: existing, status: :unchanged, matched_by: matched_by)
+        end
       end
 
       def find_conflicting_item(attributes, matched_by)
@@ -131,6 +149,10 @@ module SourceMonitor
         end
       end
 
+      # Attributes that should not trigger an "updated" status when they change.
+      # Metadata contains feedjira object references that differ between parses.
+      IGNORED_CHANGE_ATTRIBUTES = %w[metadata].freeze
+
       def apply_attributes(record, attributes)
         attributes = attributes.dup
         metadata = attributes.delete(:metadata)
@@ -138,6 +160,10 @@ module SourceMonitor
         record.metadata = metadata if metadata
       end
 
+      def significant_changes?(record)
+        (record.changed - IGNORED_CHANGE_ATTRIBUTES).any?
+      end
+
       def build_attributes
         entry_parser.parse
       end

data/lib/source_monitor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SourceMonitor
-  VERSION = "0.6.0"
+  VERSION = "0.7.1"
 end

data/lib/tasks/test_fast.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+namespace :test do
+  desc "Run tests excluding slow integration and system tests"
+  task fast: :environment do
+    $stdout.puts "Running tests excluding integration/ and system/ directories..."
+    test_files = Dir["test/**/*_test.rb"]
+      .reject { |f| f.start_with?("test/integration/", "test/system/") }
+    system("bin/rails", "test", *test_files, exception: true)
+  end
+end