Move the event emitting functions to the telemetry module.

Author: tompave

lib/fun_with_flags/store.ex

@@ -3,7 +3,7 @@ defmodule FunWithFlags.Store do
 
   require Logger
   alias FunWithFlags.Store.Cache
-  alias FunWithFlags.{Config, Flag}
+  alias FunWithFlags.{Config, Flag, Telemetry}
 
   import FunWithFlags.Config, only: [persistence_adapter: 0]
 
@@ -15,11 +15,11 @@ defmodule FunWithFlags.Store do
       {:miss, reason, stale_value_or_nil} ->
         case persistence_adapter().get(flag_name) do
           {:ok, flag} ->
-            emit_persistence_telemetry({:ok, nil}, :read, flag_name, nil)
+            Telemetry.emit_persistence_event({:ok, nil}, :read, flag_name, nil)
             Cache.put(flag)
             {:ok, flag}
           err = {:error, _reason} ->
-            emit_persistence_telemetry(err, :read, flag_name, nil)
+            Telemetry.emit_persistence_event(err, :read, flag_name, nil)
             try_to_use_the_cached_value(reason, stale_value_or_nil, flag_name)
         end
     end
@@ -39,7 +39,7 @@ defmodule FunWithFlags.Store do
   def put(flag_name, gate) do
     flag_name
     |> persistence_adapter().put(gate)
-    |> emit_persistence_telemetry(:write, flag_name, gate)
+    |> Telemetry.emit_persistence_event(:write, flag_name, gate)
     |> publish_change()
     |> cache_persistence_result()
   end
@@ -49,7 +49,7 @@ defmodule FunWithFlags.Store do
   def delete(flag_name, gate) do
     flag_name
     |> persistence_adapter().delete(gate)
-    |> emit_persistence_telemetry(:delete_gate, flag_name, gate)
+    |> Telemetry.emit_persistence_event(:delete_gate, flag_name, gate)
     |> publish_change()
     |> cache_persistence_result()
   end
@@ -59,7 +59,7 @@ defmodule FunWithFlags.Store do
   def delete(flag_name) do
     flag_name
     |> persistence_adapter().delete()
-    |> emit_persistence_telemetry(:delete_flag, flag_name, nil)
+    |> Telemetry.emit_persistence_event(:delete_flag, flag_name, nil)
     |> publish_change()
     |> cache_persistence_result()
   end
@@ -70,22 +70,22 @@ defmodule FunWithFlags.Store do
     Logger.debug fn -> "FunWithFlags: reloading cached flag '#{flag_name}' from storage " end
     flag_name
     |> persistence_adapter().get()
-    |> emit_persistence_telemetry(:reload, flag_name, nil)
+    |> Telemetry.emit_persistence_event(:reload, flag_name, nil)
     |> cache_persistence_result()
   end
 
 
   @spec all_flags() :: {:ok, [FunWithFlags.Flag.t]} | {:error, any()}
   def all_flags do
     persistence_adapter().all_flags()
-    |> emit_persistence_telemetry(:read_all_flags, nil, nil)
+    |> Telemetry.emit_persistence_event(:read_all_flags, nil, nil)
   end
 
 
   @spec all_flag_names() :: {:ok, [atom]} | {:error, any()}
   def all_flag_names do
     persistence_adapter().all_flag_names()
-    |> emit_persistence_telemetry(:read_all_flag_names, nil, nil)
+    |> Telemetry.emit_persistence_event(:read_all_flag_names, nil, nil)
   end
 
   defp cache_persistence_result(result = {:ok, flag}) do
@@ -109,30 +109,4 @@ defmodule FunWithFlags.Store do
   defp publish_change(result) do
     result
   end
-
-  # Receive the flag name as an explicit parameter rather than pattern matching
-  # it from the `{:ok, %Flag{}}`, because that tuple is only available on success,
-  # and it's therefore not available when pipelining on an error.
-  #
-  defp emit_persistence_telemetry(result = {:ok, _}, event_name, flag_name, gate) do
-    metadata = %{
-      flag_name: flag_name,
-      gate: gate,
-    }
-
-    FunWithFlags.Telemetry.persistence_event(event_name, metadata)
-    result
-  end
-
-  defp emit_persistence_telemetry(result = {:error, reason}, event_name, flag_name, gate) do
-    metadata = %{
-      flag_name: flag_name,
-      gate: gate,
-      error: reason,
-      original_event: event_name
-    }
-
-    FunWithFlags.Telemetry.persistence_event(:error, metadata)
-    result
-  end
 end

lib/fun_with_flags/telemetry.ex

@@ -22,9 +22,49 @@ defmodule FunWithFlags.Telemetry do
 
   require Logger
 
+  @typedoc false
+  @type pipelining_value :: {:ok, any()} | {:error, any()}
+
+  # Receive the flag name as an explicit parameter rather than pattern matching
+  # it from the `{:ok, _}` tuple, because:
+  #
+  # * That tuple is only available on success, and it's therefore not available
+  #   when pipelining on an error.
+  # * It makes it possible to use this function even when the :ok result does
+  #   not contain a flag.
+  #
   @doc false
-  @spec persistence_event(atom, :telemetry.event_metadata()) :: :ok
-  def persistence_event(event_name, metadata) do
+  @spec emit_persistence_event(
+    pipelining_value(),
+    event_name :: atom(),
+    flag_name :: (atom() | nil),
+    gate :: (FunWithFlags.Gate.t | nil)
+  ) :: pipelining_value()
+  def emit_persistence_event(result = {:ok, _}, event_name, flag_name, gate) do
+    metadata = %{
+      flag_name: flag_name,
+      gate: gate,
+    }
+
+    do_send_event([:fun_with_flags, :persistence, event_name], metadata)
+    result
+  end
+
+  def emit_persistence_event(result = {:error, reason}, event_name, flag_name, gate) do
+    metadata = %{
+      flag_name: flag_name,
+      gate: gate,
+      error: reason,
+      original_event: event_name
+    }
+
+    do_send_event([:fun_with_flags, :persistence, :error], metadata)
+    result
+  end
+
+  @doc false
+  @spec do_send_event([atom], :telemetry.event_metadata()) :: :ok
+  def do_send_event(event_name, metadata) do
     measurements = %{
       system_time: :erlang.system_time()
     }
@@ -33,11 +73,6 @@ defmodule FunWithFlags.Telemetry do
       "Telemetry event: #{event_name}, metadata: #{inspect(metadata)}, measurements: #{inspect(measurements)}"
     end)
 
-    :telemetry.execute([:fun_with_flags, :persistence, event_name], measurements, metadata)
+    :telemetry.execute(event_name, measurements, metadata)
   end
-
-  # @spec as_milliseconds(integer) :: integer
-  # defp as_milliseconds(time) do
-  #   :erlang.convert_time_unit(time, :native, :millisecond)
-  # end
 end

test/fun_with_flags/telemetry_test.exs

@@ -2,20 +2,67 @@ defmodule FunWithFlags.TelemetryTest do
   use ExUnit.Case, async: true
 
   alias FunWithFlags.Telemetry, as: FWFTel
+  alias FunWithFlags.Gate
 
   @moduletag :telemetry
 
-  describe "persistence_event()" do
+  describe "emit_persistence_event()" do
+    test "with a success tuple" do
+      result = {:ok, "something"}
+      event_name = :some_event
+      flag_name = :some_flag
+      gate = %Gate{type: :boolean, enabled: true}
+
+      ref = :telemetry_test.attach_event_handlers(self(), [[:fun_with_flags, :persistence, event_name]])
+
+      assert ^result = FWFTel.emit_persistence_event(result, event_name, flag_name, gate)
+
+      assert_received {
+        [:fun_with_flags, :persistence, ^event_name],
+        ^ref,
+        %{system_time: time_value},
+        %{flag_name: ^flag_name, gate: ^gate}
+      }
+
+      assert is_integer(time_value)
+
+      :telemetry.detach(ref)
+    end
+
+    test "with an error tuple" do
+      result = {:error, "some error"}
+      event_name = :some_event
+      flag_name = :some_flag
+      gate = %Gate{type: :boolean, enabled: true}
+
+      ref = :telemetry_test.attach_event_handlers(self(), [[:fun_with_flags, :persistence, :error]])
+
+      assert ^result = FWFTel.emit_persistence_event(result, event_name, flag_name, gate)
+
+      assert_received {
+        [:fun_with_flags, :persistence, :error],
+        ^ref,
+        %{system_time: time_value},
+        %{flag_name: ^flag_name, gate: ^gate, error: "some error", original_event: ^event_name}
+      }
+
+      assert is_integer(time_value)
+
+      :telemetry.detach(ref)
+    end
+  end
+
+  describe "do_send_event()" do
     test "it emits an event with the right prefix and measures" do
       metadata = %{foo: "bar"}
-      event = :monkey
+      event = [:foo, :bar, :monkey]
 
-      ref = :telemetry_test.attach_event_handlers(self(), [[:fun_with_flags, :persistence, event]])
+      ref = :telemetry_test.attach_event_handlers(self(), [event])
 
-      assert :ok = FWFTel.persistence_event(event, metadata)
+      assert :ok = FWFTel.do_send_event(event, metadata)
 
       assert_received {
-        [:fun_with_flags, :persistence, ^event],
+        ^event,
         ^ref,
         %{system_time: time_value},
         ^metadata