feat: able to manually handle/report error/exit/throw (#28)

lib/tower.ex

@@ -15,18 +15,18 @@ defmodule Tower do
     :ok = Tower.LoggerHandler.detach()
   end
 
-  def handle_exception(exception, stacktrace, meta)
+  def handle_exception(exception, stacktrace, meta \\ %{})
       when is_exception(exception) and is_list(stacktrace) do
     Event.from_exception(exception, stacktrace, meta)
     |> report_event()
   end
 
-  def handle_throw(reason, stacktrace, metadata) do
+  def handle_throw(reason, stacktrace, metadata \\ %{}) do
     Event.from_throw(reason, stacktrace, metadata)
     |> report_event()
   end
 
-  def handle_exit(reason, stacktrace, metadata) do
+  def handle_exit(reason, stacktrace, metadata \\ %{}) do
     Event.from_exit(reason, stacktrace, metadata)
     |> report_event()
   end

lib/tower/event.ex

@@ -10,9 +10,9 @@ defmodule Tower.Event do
           log_event_meta: :logger.metadata()
         }
 
-  def from_exception(exception, stacktrace, %{time: time} = log_event_meta) do
+  def from_exception(exception, stacktrace, log_event_meta) do
     %__MODULE__{
-      time: time,
+      time: Map.get(log_event_meta, :time, :logger.timestamp()),
       level: :error,
       kind: :error,
       reason: exception,
@@ -21,9 +21,9 @@ defmodule Tower.Event do
     }
   end
 
-  def from_exit(reason, stacktrace, %{time: time} = log_event_meta) do
+  def from_exit(reason, stacktrace, log_event_meta) do
     %__MODULE__{
-      time: time,
+      time: Map.get(log_event_meta, :time, :logger.timestamp()),
       level: :error,
       kind: :exit,
       reason: reason,
@@ -32,9 +32,9 @@ defmodule Tower.Event do
     }
   end
 
-  def from_throw(reason, stacktrace, %{time: time} = log_event_meta) do
+  def from_throw(reason, stacktrace, log_event_meta) do
     %__MODULE__{
-      time: time,
+      time: Map.get(log_event_meta, :time, :logger.timestamp()),
       level: :error,
       kind: :throw,
       reason: reason,

test/tower_test.exs

@@ -263,6 +263,86 @@ defmodule TowerTest do
     assert_in_delta(time, :logger.timestamp(), 100_000)
   end
 
+  test "reports Exception manually" do
+    in_unlinked_process(fn ->
+      try do
+        1 / 0
+      rescue
+        e ->
+          Tower.handle_exception(e, __STACKTRACE__)
+      end
+    end)
+
+    assert_eventually(
+      [
+        %{
+          time: time,
+          level: :error,
+          kind: ArithmeticError,
+          reason: "bad argument in arithmetic expression",
+          stacktrace: stacktrace
+        }
+      ] = reported_events()
+    )
+
+    assert_in_delta(time, :logger.timestamp(), 100_000)
+    assert is_list(stacktrace)
+  end
+
+  @tag capture_log: true
+  test "manually reports a thrown string" do
+    in_unlinked_process(fn ->
+      try do
+        throw("error")
+      catch
+        x ->
+          Tower.handle_throw(x, __STACKTRACE__)
+      end
+    end)
+
+    assert_eventually(
+      [
+        %{
+          time: time,
+          level: :error,
+          kind: :throw,
+          reason: "error",
+          stacktrace: stacktrace
+        }
+      ] = reported_events()
+    )
+
+    assert_in_delta(time, :logger.timestamp(), 100_000)
+    assert is_list(stacktrace)
+  end
+
+  @tag capture_log: true
+  test "manually reports an abnormal exit" do
+    in_unlinked_process(fn ->
+      try do
+        exit(:abnormal)
+      catch
+        :exit, reason ->
+          Tower.handle_exit(reason, __STACKTRACE__)
+      end
+    end)
+
+    assert_eventually(
+      [
+        %{
+          time: time,
+          level: :error,
+          kind: :exit,
+          reason: :abnormal,
+          stacktrace: stacktrace
+        }
+      ] = reported_events()
+    )
+
+    assert_in_delta(time, :logger.timestamp(), 100_000)
+    assert is_list(stacktrace)
+  end
+
   defp in_unlinked_process(fun) when is_function(fun, 0) do
     {:ok, pid} = Task.Supervisor.start_link()