Include muted and error metadata for new occurrence telemetry

Aside from the occurrence itself, the new occurrence telemetry event now
also includes the error and the muted flag so users can choose wether
the occurrence should be reported or not.

Author: crbelaus

lib/error_tracker.ex

@@ -336,7 +336,7 @@ defmodule ErrorTracker do
     {existing_status, muted} =
       case Repo.one(status_and_muted_query) do
         {existing_status, muted} -> {existing_status, muted}
-        nil -> {nil, nil}
+        nil -> {nil, false}
       end
 
     {:ok, {error, occurrence}} =
@@ -369,6 +369,8 @@ defmodule ErrorTracker do
         {error, occurrence}
       end)
 
+    occurrence = %Occurrence{occurrence | error: error}
+
     # 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
@@ -378,9 +380,7 @@ defmodule ErrorTracker do
       nil -> Telemetry.new_error(error)
     end
 
-    # Send telemetry for new occurrences if not muted
-    if !muted, do: Telemetry.new_occurrence(occurrence)
-
-    %Occurrence{occurrence | error: error}
+    Telemetry.new_occurrence(occurrence, muted)
+    occurrence
   end
 end

lib/error_tracker/telemetry.ex

@@ -31,39 +31,45 @@ defmodule ErrorTracker.Telemetry do
   Each event is emitted with some measures and metadata, which can be used to
   receive information without having to query the database again:
 
-  | event                                   | measures       | metadata      |
-  | --------------------------------------- | -------------- | ------------- |
-  | `[:error_tracker, :error, :new]`        | `:system_time` | `:error`      |
-  | `[:error_tracker, :error, :unresolved]` | `:system_time` | `:error`      |
-  | `[:error_tracker, :error, :resolved]`   | `:system_time` | `:error`      |
-  | `[:error_tracker, :occurrence, :new]`   | `:system_time` | `:occurrence` |
+  | event                                   | measures       | metadata                          |
+  | --------------------------------------- | -------------- | ----------------------------------|
+  | `[:error_tracker, :error, :new]`        | `:system_time` | `:error`                          |
+  | `[:error_tracker, :error, :unresolved]` | `:system_time` | `:error`                          |
+  | `[:error_tracker, :error, :resolved]`   | `:system_time` | `:error`                          |
+  | `[:error_tracker, :occurrence, :new]`   | `:system_time` | `:occurrence`, `:error`, `:muted` |
+
+  The metadata keys contain the following data:
+
+  * `:error` - An `%ErrorTracker.Error{}` struct representing the error.
+  * `:occurrence` - An `%ErrorTracker.Occurrence{}` struct representing the occurrence.
+  * `:muted` - A boolean indicating whether the error is muted or not.
   """
 
   @doc false
-  def new_error(error) do
+  def new_error(error = %ErrorTracker.Error{}) do
     measurements = %{system_time: System.system_time()}
     metadata = %{error: error}
     :telemetry.execute([:error_tracker, :error, :new], measurements, metadata)
   end
 
   @doc false
-  def unresolved_error(error) do
+  def unresolved_error(error = %ErrorTracker.Error{}) do
     measurements = %{system_time: System.system_time()}
     metadata = %{error: error}
     :telemetry.execute([:error_tracker, :error, :unresolved], measurements, metadata)
   end
 
   @doc false
-  def resolved_error(error) do
+  def resolved_error(error = %ErrorTracker.Error{}) do
     measurements = %{system_time: System.system_time()}
     metadata = %{error: error}
     :telemetry.execute([:error_tracker, :error, :resolved], measurements, metadata)
   end
 
   @doc false
-  def new_occurrence(occurrence) do
+  def new_occurrence(occurrence = %ErrorTracker.Occurrence{}, muted) when is_boolean(muted) do
     measurements = %{system_time: System.system_time()}
-    metadata = %{occurrence: occurrence}
+    metadata = %{error: occurrence.error, occurrence: occurrence, muted: muted}
     :telemetry.execute([:error_tracker, :occurrence, :new], measurements, metadata)
   end
 end

test/error_tracker/telemetry_test.exs

@@ -23,7 +23,7 @@ defmodule ErrorTracker.TelemetryTest do
     assert_receive {:telemetry_event, [:error_tracker, :error, :new], _, %{error: %Error{}}}
 
     assert_receive {:telemetry_event, [:error_tracker, :occurrence, :new], _,
-                    %{occurrence: %Occurrence{}}}
+                    %{occurrence: %Occurrence{}, muted: false}}
 
     # The error is already known so the new error event won't be emitted
     ErrorTracker.report(exception, stacktrace)
@@ -32,15 +32,14 @@ defmodule ErrorTracker.TelemetryTest do
                    150
 
     assert_receive {:telemetry_event, [:error_tracker, :occurrence, :new], _,
-                    %{occurrence: %Occurrence{}}}
+                    %{occurrence: %Occurrence{}, muted: false}}
 
-    # The error is muted so the new occurrence event won't be emitted
+    # The error is muted so the new occurrence event will include the muted=true metadata
     ErrorTracker.mute(error)
     ErrorTracker.report(exception, stacktrace)
 
-    refute_receive {:telemetry_event, [:error_tracker, :occurrence, :new], _,
-                    %{occurrence: %Occurrence{}}},
-                   150
+    assert_receive {:telemetry_event, [:error_tracker, :occurrence, :new], _,
+                    %{occurrence: %Occurrence{}, muted: true}}
   end
 
   test "events are emitted for resolved and unresolved errors" do