Replace runtime codegen with functions defined in Peep.EventHandler

lib/peep.ex

@@ -141,14 +141,27 @@ defmodule Peep do
   """
   def get_all_metrics(name) do
     case Peep.Persistent.fetch(name) do
-      Peep.Persistent.persistent(storage: {storage_mod, storage}) = p ->
+      Peep.Persistent.persistent(storage: {storage_mod, storage}, global_tags: global_tags) = p ->
         storage_mod.get_all_metrics(storage, p)
+        |> extend_with(global_tags)
 
       _ ->
         nil
     end
   end
 
+  defp extend_with(metrics, tags) when tags == %{}, do: metrics
+
+  defp extend_with(metrics, global_tags) do
+    Map.new(metrics, fn {metric, measurements} ->
+      updated = Map.new(measurements, fn {tags, val} ->
+        {Map.merge(global_tags, tags), val}
+      end)
+
+      {metric, updated}
+    end)
+  end
+
   @doc """
   Removes metrics whose metadata contains the specified tag patterns.
 
@@ -245,7 +258,6 @@ defmodule Peep do
       Peep.Persistent.new(options)
       |> Peep.Persistent.store()
 
-    :ok = Peep.Codegen.create(options)
     handler_ids = EventHandler.attach(name)
 
     statsd_opts = options.statsd
@@ -301,7 +313,6 @@ defmodule Peep do
 
   @impl true
   def terminate(_reason, %{name: name, handler_ids: handler_ids}) do
-    Peep.Codegen.purge(name)
     Peep.Persistent.erase(name)
     EventHandler.detach(handler_ids)
   end

lib/peep/event_handler.ex

@@ -1,13 +1,12 @@
 defmodule Peep.EventHandler do
   @moduledoc false
 
-  @compile :inline
+  @compile {:inline, keep?: 3, meta: 3, fetch_measurement: 3}
 
   import Peep.Persistent, only: [persistent: 1]
 
   def attach(name) do
     persistent(events_to_metrics: metrics_by_event) = Peep.Persistent.fetch(name)
-    module = Peep.Codegen.module(name)
 
     for {event_name, _metrics} <- metrics_by_event do
       handler_id = handler_id(event_name, name)
@@ -16,8 +15,8 @@ defmodule Peep.EventHandler do
         :telemetry.attach(
           handler_id,
           event_name,
-          &module.handle_event/4,
-          []
+          &__MODULE__.handle_event/4,
+          name
         )
 
       handler_id
@@ -32,4 +31,77 @@ defmodule Peep.EventHandler do
   defp handler_id(event_name, peep_name) do
     {__MODULE__, peep_name, event_name}
   end
+
+  def handle_event(event, measurements, metadata, name) do
+    persistent(
+      events_to_metrics: %{^event => metrics},
+      storage: {storage_mod, storage}
+    ) = Peep.Persistent.fetch(name)
+
+    store_metrics(metrics, measurements, metadata, storage_mod, storage)
+  end
+
+  defp store_metrics([], _measurements, _metadata, _mod, _data), do: :ok
+
+  defp store_metrics([{metric, id} | rest], measurements, metadata, mod, data) do
+    %{
+      measurement: measurement,
+      tag_values: tag_values,
+      tags: tags,
+      keep: keep
+    } = metric
+
+    if keep?(keep, metadata, measurement) do
+      # credo:disable-for-next-line Credo.Check.Refactor.Nesting
+      case fetch_measurement(measurement, measurements, metadata) do
+        value when is_number(value) ->
+          mod.insert_metric(
+            data,
+            id,
+            metric,
+            value,
+            meta(metadata, tag_values, tags)
+          )
+
+        _ ->
+          nil
+      end
+    end
+
+    store_metrics(rest, measurements, metadata, mod, data)
+  end
+
+  defp keep?(keep, metadata, measurement) when is_function(keep, 2),
+    do: keep.(metadata, measurement)
+
+  defp keep?(keep, metadata, _measurement) when is_function(keep, 1), do: keep.(metadata)
+  defp keep?(_keep, _metadata, _measurement), do: true
+
+  # When selected list is empty, just return empty map
+  defp meta(_tags, _map, []), do: %{}
+  defp meta(meta, _map, tags) when is_function(tags, 1), do: tags.(meta)
+  defp meta(tags, map, keys), do: Map.take(map.(tags), keys)
+
+  defp fetch_measurement(%Telemetry.Metrics.Counter{}, _measurements, _metadata) do
+    1
+  end
+
+  defp fetch_measurement(measurement, measurements, metadata) do
+    case measurement do
+      nil ->
+        nil
+
+      fun when is_function(fun, 1) ->
+        fun.(measurements)
+
+      fun when is_function(fun, 2) ->
+        fun.(measurements, metadata)
+
+      key ->
+        case measurements do
+          %{^key => value} -> value
+          _ -> 1
+        end
+    end
+  end
 end

lib/peep/persistent.ex

@@ -8,7 +8,8 @@ defmodule Peep.Persistent do
     :storage,
     events_to_metrics: %{},
     ids_to_metrics: %{},
-    metrics_to_ids: %{}
+    metrics_to_ids: %{},
+    global_tags: %{}
   ])
 
   @compile {:inline, key: 1, fetch: 1}
@@ -28,12 +29,18 @@ defmodule Peep.Persistent do
             storage: storage(),
             events_to_metrics: events_to_metrics(),
             ids_to_metrics: ids_to_metrics(),
-            metrics_to_ids: metrics_to_ids()
+            metrics_to_ids: metrics_to_ids(),
+            global_tags: map()
           )
 
   @spec new(Peep.Options.t()) :: t()
   def new(%Peep.Options{} = options) do
-    %Peep.Options{name: name, storage: storage_impl, metrics: metrics} = options
+    %Peep.Options{
+      name: name,
+      storage: storage_impl,
+      metrics: metrics,
+      global_tags: global_tags
+    } = options
 
     storage =
       case storage_impl do
@@ -58,7 +65,8 @@ defmodule Peep.Persistent do
       storage: storage,
       events_to_metrics: events_to_metrics,
       ids_to_metrics: ids_to_metrics,
-      metrics_to_ids: metrics_to_ids
+      metrics_to_ids: metrics_to_ids,
+      global_tags: global_tags
     )
   end