error-tracker/lib/error_tracker/telemetry.ex at 1b70e4c3eb2a2e9ff9e749170ef1c3a6530e7a91 · elixir-error-tracker/error-tracker · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
defmodule ErrorTracker.Telemetry do
  @moduledoc """
  Telemetry events of ErrorTracker.

  ErrorTracker emits some events to allow third parties to receive information
  of errors and occurrences stored.

  ### Error events

  Those occur during the life cycle of an error:

  * `[:error_tracker, :error, :new]`: is emitted when a new error is stored and
  no previous occurrences were known.

  * `[:error_tracker, :error, :resolved]`: is emitted when a new error is marked
  as resolved on the UI.

  * `[:error_tracker, :error, :unresolved]`: is emitted when a new error is
  marked as unresolved on the UI or a new occurrence is registered, moving the
  error to the unresolved state.

  ### Occurrence events

  There is only one event emitted for occurrences:

  * `[:error_tracker, :occurrence, :new]`: is emitted when a new occurrence is
  stored.

  ### Measures and metadata

  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`, `: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, %ErrorTracker.Occurrence{} = occurrence) do
    measurements = %{system_time: System.system_time()}
    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, 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

  @doc false
  def resolved_error(%ErrorTracker.Error{} = 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(%ErrorTracker.Occurrence{} = occurrence, muted) when is_boolean(muted) do
    measurements = %{system_time: System.system_time()}
    metadata = %{error: occurrence.error, occurrence: occurrence, muted: muted}
    :telemetry.execute([:error_tracker, :occurrence, :new], measurements, metadata)
  end
end