fix: Propagate muted flag to :error telemetry events (#174)

Repo.insert!/2 with on_conflict: [set: [...]] only round-trips the
columns listed in the set clause (status, last_occurrence_at). As a
result, the returned %Error{} struct always carried muted: false — the
schema default — even when the DB row was muted.

upsert_error!/5 already fetches muted from the DB in a pre-query, but
never applied it to the in-memory struct before handing it to
Telemetry.new_error/1 and Telemetry.unresolved_error/1. This caused
subscribers of [:error_tracker, :error, :new] and
[:error_tracker, :error, :unresolved] to always see muted: false,
making it impossible to silence alerts for muted errors at the
telemetry level.

Fix: stamp the already-fetched muted value onto the struct right before
telemetry dispatch. No new queries, no public API change — the muted
field already exists on the Error schema, so existing subscribers start
receiving the correct value without any changes on their side.

Adds a regression test that mutes and resolves an error, re-triggers
it, and asserts the :unresolved payload carries muted: true.

Co-authored-by: Javier Segura <javier.segura@tamoe.es>

Author: reciproco

lib/error_tracker.ex

@@ -371,6 +371,12 @@ defmodule ErrorTracker do
     %Occurrence{} = occurrence
     occurrence = %{occurrence | error: error}
 
+    # `Repo.insert!(_, on_conflict: [set: [...]])` only round-trips the columns
+    # it sets, so the in-memory struct keeps `muted: false` (the schema default)
+    # even when the DB row is muted. Stamp it with the value we already fetched
+    # so subscribers of `[:error_tracker, :error, :*]` see the real flag.
+    error = %{error | muted: muted}
+
     # If the error existed and was marked as resolved before this exception,
     # sent a Telemetry event
     # If it is a new error, sent a Telemetry event

test/error_tracker/telemetry_test.exs

@@ -51,4 +51,24 @@ defmodule ErrorTracker.TelemetryTest do
 
     assert_receive {:telemetry_event, [:error_tracker, :error, :unresolved], _, %{error: %Error{}}}
   end
+
+  test "the :unresolved event carries the muted flag for muted errors" do
+    {exception, stacktrace} =
+      try do
+        raise "This is a test"
+      rescue
+        e -> {e, __STACKTRACE__}
+      end
+
+    %Occurrence{error: error = %Error{}} = ErrorTracker.report(exception, stacktrace)
+    {:ok, error} = ErrorTracker.mute(error)
+    {:ok, _resolved} = ErrorTracker.resolve(error)
+
+    # Trigger the same error again. It exists and is resolved, so the
+    # :unresolved telemetry event fires — and its `error` struct must
+    # reflect the muted flag stored in the DB.
+    ErrorTracker.report(exception, stacktrace)
+
+    assert_receive {:telemetry_event, [:error_tracker, :error, :unresolved], _, %{error: %Error{muted: true}}}
+  end
 end