feat: Include occurrence in error telemetry events (#173)

Add the triggering `%Occurrence{}` struct to the metadata of
`[:error_tracker, :error, :new]` and `[:error_tracker, :error, :unresolved]`
events. Manual unresolves (via the UI) emit `occurrence: nil` since no
occurrence is involved.

Author: gaggle

lib/error_tracker.ex

@@ -381,9 +381,9 @@ defmodule ErrorTracker do
     # sent a Telemetry event
     # If it is a new error, sent a Telemetry event
     case existing_status do
-      :resolved -> Telemetry.unresolved_error(error)
+      :resolved -> Telemetry.previously_resolved_error(error, occurrence)
       :unresolved -> :noop
-      nil -> Telemetry.new_error(error)
+      nil -> Telemetry.new_error(error, occurrence)
     end
 
     Telemetry.new_occurrence(occurrence, muted)

lib/error_tracker/telemetry.ex

@@ -31,31 +31,41 @@ 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`, `:error`, `:muted` |
+  | event                                   | measures       | metadata                                        |
+  | --------------------------------------- | -------------- | ----------------------------------------------- |
+  | `[:error_tracker, :error, :new]`        | `:system_time` | `:error`, `:occurrence`                         |
+  | `[:error_tracker, :error, :unresolved]` | `:system_time` | `:error`, `:occurrence` (nullable)              |
+  | `[: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.
+    For `:new` error events this is the first occurrence. For `:unresolved` events this
+    is the occurrence that triggered the state change, or `nil` when the error was manually
+    unresolved from the UI.
   * `:muted` - A boolean indicating whether the error is muted or not.
   """
 
   @doc false
-  def new_error(%ErrorTracker.Error{} = error) do
+  def new_error(%ErrorTracker.Error{} = error, %ErrorTracker.Occurrence{} = occurrence) do
     measurements = %{system_time: System.system_time()}
-    metadata = %{error: error}
+    metadata = %{error: error, occurrence: occurrence}
     :telemetry.execute([:error_tracker, :error, :new], measurements, metadata)
   end
 
   @doc false
   def unresolved_error(%ErrorTracker.Error{} = error) do
     measurements = %{system_time: System.system_time()}
-    metadata = %{error: error}
+    metadata = %{error: error, occurrence: nil}
+    :telemetry.execute([:error_tracker, :error, :unresolved], measurements, metadata)
+  end
+
+  @doc false
+  def previously_resolved_error(%ErrorTracker.Error{} = error, %ErrorTracker.Occurrence{} = occurrence) do
+    measurements = %{system_time: System.system_time()}
+    metadata = %{error: error, occurrence: occurrence}
     :telemetry.execute([:error_tracker, :error, :unresolved], measurements, metadata)
   end
 

test/error_tracker/telemetry_test.exs

@@ -19,8 +19,8 @@ defmodule ErrorTracker.TelemetryTest do
       end
 
     # Since the error is new, both the new error and new occurrence events will be emitted
-    %Occurrence{error: error = %Error{}} = ErrorTracker.report(exception, stacktrace)
-    assert_receive {:telemetry_event, [:error_tracker, :error, :new], _, %{error: %Error{}}}
+    occurrence = %Occurrence{error: error = %Error{}} = ErrorTracker.report(exception, stacktrace)
+    assert_receive {:telemetry_event, [:error_tracker, :error, :new], _, %{error: %Error{}, occurrence: ^occurrence}}
 
     assert_receive {:telemetry_event, [:error_tracker, :occurrence, :new], _, %{occurrence: %Occurrence{}, muted: false}}
 
@@ -49,7 +49,28 @@ defmodule ErrorTracker.TelemetryTest do
     # The unresolved event will be emitted
     {:ok, _unresolved} = ErrorTracker.unresolve(resolved)
 
-    assert_receive {:telemetry_event, [:error_tracker, :error, :unresolved], _, %{error: %Error{}}}
+    assert_receive {:telemetry_event, [:error_tracker, :error, :unresolved], _, %{error: %Error{}, occurrence: nil}}
+  end
+
+  test "events are emitted for previously resolved errors" do
+    {exception, stacktrace} =
+      try do
+        raise "This error was resolved but came back"
+      rescue
+        e -> {e, __STACKTRACE__}
+      end
+
+    %Occurrence{error: error = %Error{}} = ErrorTracker.report(exception, stacktrace)
+
+    ErrorTracker.resolve(error)
+
+    occurrence = ErrorTracker.report(exception, stacktrace)
+
+    assert_receive {:telemetry_event, [:error_tracker, :error, :unresolved], _,
+                    %{
+                      error: %Error{reason: "This error was resolved but came back"},
+                      occurrence: ^occurrence
+                    }}
   end
 
   test "the :unresolved event carries the muted flag for muted errors" do