fix(error-tracking): always use arity when formatting stacktrace frames

.sampo/changesets/somber-knight-otso.md

@@ -0,0 +1,5 @@
+---
+hex/posthog: patch
+---
+
+Improve error tracking grouping by always using arity to format stacktrace frames

lib/posthog/handler.ex

@@ -211,11 +211,12 @@ defmodule PostHog.Handler do
         in_app = module in in_app_modules
         filename = Keyword.get(location, :file, []) |> IO.chardata_to_string()
         lineno = Keyword.get(location, :line)
+        arity = with args when is_list(args) <- arity_or_args, do: length(args)
 
         %{
           platform: "custom",
           lang: "elixir",
-          function: Exception.format_mfa(module, function, arity_or_args),
+          function: Exception.format_mfa(module, function, arity),
           filename: filename,
           lineno: lineno,
           module: inspect(module),

test/integration_test.exs

@@ -23,8 +23,14 @@ defmodule PostHog.IntegrationTest do
         |> PostHog.Registry.via(PostHog.Sender, 1)
         |> GenServer.whereis()
 
-      send(sender_pid, :batch_time_reached)
-      :sys.get_status(sender_pid)
+      case :sys.get_state(sender_pid) do
+        %{timer_ref: ref} ->
+          send(sender_pid, {:timeout, ref, :batch_time_reached})
+          :sys.get_status(sender_pid)
+
+        _ ->
+          :ok
+      end
     end
 
     :logger.add_handler(:posthog, PostHog.Handler, %{config: config})
@@ -73,6 +79,18 @@ defmodule PostHog.IntegrationTest do
       wait.()
     end
 
+    test "anonymous function", %{wait_fun: wait} do
+      {:ok, pid} =
+        Task.start(fn ->
+          Enum.map([:foo], fn x when is_binary(x) -> :ok end)
+        end)
+
+      ref = Process.monitor(pid)
+      assert_receive({:DOWN, ^ref, _, _, _})
+
+      wait.()
+    end
+
     test "exports metadata", %{wait_fun: wait} do
       LoggerHandlerKit.Act.metadata_serialization(:all)
       Logger.error("Error with metadata")

test/posthog/handler_test.exs

@@ -1639,7 +1639,7 @@ defmodule PostHog.HandlerTest do
                        frames: [
                          %{
                            filename: "",
-                           function: ":erlang.system_time(:foo)",
+                           function: ":erlang.system_time/1",
                            in_app: false,
                            lineno: nil,
                            module: ":erlang",
@@ -1668,7 +1668,7 @@ defmodule PostHog.HandlerTest do
                        frames: [
                          %{
                            filename: "",
-                           function: ":erlang.system_time(:foo)",
+                           function: ":erlang.system_time/1",
                            in_app: false,
                            lineno: nil,
                            module: ":erlang",
@@ -1690,6 +1690,74 @@ defmodule PostHog.HandlerTest do
     end
   end
 
+  test "anonymous function in stacktrace", %{
+    handler_ref: ref,
+    config: %{supervisor_name: supervisor_name}
+  } do
+    {:ok, _pid} = Task.start(fn -> Enum.map([:foo], fn :bar -> :ok end) end)
+    LoggerHandlerKit.Assert.assert_logged(ref)
+
+    assert [event] = all_captured(supervisor_name)
+
+    if pre_19?() do
+      assert %{
+               event: "$exception",
+               properties: %{
+                 "$exception_list": [
+                   %{
+                     type: "FunctionClauseError",
+                     value:
+                       "no function clause matching in anonymous fn/1 in PostHog.HandlerTest.\"test anonymous function in stacktrace\"/1",
+                     stacktrace: %{
+                       type: "raw",
+                       frames: [
+                         %{
+                           function:
+                             "anonymous fn/1 in PostHog.HandlerTest.\"test anonymous function in stacktrace\"/1",
+                           platform: "custom",
+                           lang: "elixir"
+                         }
+                         | _
+                       ]
+                     },
+                     mechanism: %{type: "generic", handled: false}
+                   }
+                 ]
+               }
+             } = event
+    else
+      assert %{
+               event: "$exception",
+               properties: %{
+                 "$exception_list": [
+                   %{
+                     type: "FunctionClauseError",
+                     value:
+                       "no function clause matching in anonymous fn/1 in PostHog.HandlerTest.\"test anonymous function in stacktrace\"/1",
+                     stacktrace: %{
+                       type: "raw",
+                       frames: [
+                         %{
+                           function:
+                             "anonymous fn/1 in PostHog.HandlerTest.\"test anonymous function in stacktrace\"/1",
+                           platform: "custom",
+                           lang: "elixir"
+                         }
+                         | _
+                       ]
+                     },
+                     mechanism: %{type: "generic", handled: false}
+                   },
+                   %{
+                     mechanism: %{handled: true, type: "generic"},
+                     type: "Task terminating"
+                   }
+                 ]
+               }
+             } = event
+    end
+  end
+
   @tag config: [in_app_otp_apps: [:logger_handler_kit]]
   test "marks in_app frames as such", %{
     handler_ref: ref,