No longer raise if logging raises

Author: fishcakez

integration_test/cases/prepare_stream_test.exs

@@ -357,38 +357,4 @@ defmodule PrepareStreamTest do
       handle_close: [%Q{}, _, :state2],
       handle_commit: [_, :new_state2]] = A.record(agent)
   end
-
-  test "prepare_stream declare log raises and deallocates" do
-    stack = [
-      {:ok, :state},
-      {:ok, :began, :new_state},
-      {:ok, %Q{}, :newer_state},
-      {:ok, %C{}, :newest_state},
-      {:ok, :deallocated, :state2},
-      {:ok, :commited, :new_state2}
-      ]
-    {:ok, agent} = A.start_link(stack)
-
-    parent = self()
-    opts = [agent: agent, parent: parent]
-    {:ok, pool} = P.start_link(opts)
-
-    Process.flag(:trap_exit, true)
-    assert P.transaction(pool, fn(conn) ->
-      opts2 = [log: fn(_) -> raise "oops" end]
-      stream = P.prepare_stream(conn, %Q{}, [:param], opts2)
-      assert_raise RuntimeError, "oops", fn() -> Enum.to_list(stream) end
-      :hi
-    end) == {:ok, :hi}
-
-    assert [
-      connect: [_],
-      handle_begin: [_, :state],
-      handle_prepare: [%Q{}, _, :new_state],
-      handle_declare: [%Q{}, [:param], _, :newer_state],
-      handle_deallocate: [%Q{}, %C{}, _, :newest_state],
-      handle_commit: [_, :state2]
-      ] = A.record(agent)
-  end
-
 end

integration_test/cases/stream_test.exs

@@ -1,5 +1,6 @@
 defmodule StreamTest do
   use ExUnit.Case, async: true
+  import ExUnit.CaptureLog
 
   alias TestPool, as: P
   alias TestAgent, as: A
@@ -401,34 +402,37 @@ defmodule StreamTest do
       {:handle_declare, [%Q{}, [:param], _, :new_state]} | _] = A.record(agent)
   end
 
-  test "stream declare log raises and deallocates" do
+  test "stream declare log raises and continues" do
     stack = [
       {:ok, :state},
       {:ok, :began, :new_state},
       {:ok, %C{}, :newer_state},
-      {:ok, :deallocated, :newest_state},
-      {:ok, :commited, :state2}
+      {:deallocate, %R{}, :newest_state},
+      {:ok, :deallocated, :state2},
+      {:ok, :commited, :new_state2}
       ]
     {:ok, agent} = A.start_link(stack)
 
     parent = self()
     opts = [agent: agent, parent: parent]
     {:ok, pool} = P.start_link(opts)
 
-    Process.flag(:trap_exit, true)
     assert P.transaction(pool, fn(conn) ->
-      opts2 = [log: fn(_) -> raise "oops" end]
+      opts2 = [log: fn(_) -> raise "logging oops" end]
       stream = P.stream(conn, %Q{}, [:param], opts2)
-      assert_raise RuntimeError, "oops", fn() -> Enum.to_list(stream) end
+      assert capture_log(fn() ->
+        assert Enum.to_list(stream) == [%R{}]
+      end) =~ "logging oops"
       :hi
     end) == {:ok, :hi}
 
     assert [
       connect: [_],
       handle_begin: [_, :state],
       handle_declare: [%Q{}, [:param], _, :new_state],
-      handle_deallocate: [%Q{}, %C{}, _, :newer_state],
-      handle_commit: [_, :newest_state]
+      handle_first: [%Q{}, %C{}, _, :newer_state],
+      handle_deallocate: [%Q{}, %C{}, _, :newest_state],
+      handle_commit: [_, :state2]
       ] = A.record(agent)
   end
 

lib/db_connection.ex

@@ -72,6 +72,8 @@ defmodule DBConnection do
   `run/3` or `transaction/3` fun and using the run/transaction
   connection reference (`t`).
   """
+  require Logger
+
   defstruct [:pool_mod, :pool_ref, :conn_mod, :conn_ref]
 
   @typedoc """
@@ -1189,7 +1191,13 @@ defmodule DBConnection do
 
   defp log(call, query, params, log, times, result) do
     entry = DBConnection.LogEntry.new(call, query, params, times, entry_result(result))
-    log(log, entry)
+    try do
+      log(log, entry)
+    catch
+      kind, reason ->
+        stack = System.stacktrace()
+        log_failed(entry, kind, reason, stack)
+    end
     log_result(result)
   end
 
@@ -1208,6 +1216,17 @@ defmodule DBConnection do
   end
   defp log_result(other), do: other
 
+  defp log_failed(entry, kind, reason, stack) do
+    try do
+      Logger.error(fn() ->
+        "an exception was raised logging #{inspect entry}: " <> Exception.format(kind, reason, stack)
+      end)
+    catch
+      _, _ ->
+        :ok
+    end
+  end
+
   defp run_begin(conn, fun, opts) do
     try do
       fun.(conn)