replace config hackney with finch

Author: savhappy

config/config.exs

@@ -6,7 +6,7 @@ if config_env() == :test do
     tags: %{},
     enable_source_code_context: true,
     root_source_code_paths: [File.cwd!()],
-    hackney_opts: [recv_timeout: 50, pool: :sentry_pool],
+    finch_opts: [recv_timeout: 50, pool: :sentry_pool],
     send_result: :sync,
     send_max_attempts: 1,
     dedup_events: false,

lib/mix/tasks/sentry.send_test_event.ex

@@ -67,7 +67,7 @@ defmodule Mix.Tasks.Sentry.SendTestEvent do
     end
 
     Mix.shell().info("current environment_name: #{inspect(to_string(Config.environment_name()))}")
-    Mix.shell().info("hackney_opts: #{inspect(Config.hackney_opts())}\n")
+    Mix.shell().info("finch_opts: #{inspect(Config.finch_opts())}\n")
   end
 
   defp send_event(opts) do

lib/sentry/config.ex

@@ -284,11 +284,11 @@ defmodule Sentry.Config do
     client: [
       type: :atom,
       type_doc: "`t:module/0`",
-      default: Sentry.HackneyClient,
+      default: Sentry.FinchClient,
       doc: """
       A module that implements the `Sentry.HTTPClient`
-      behaviour. Defaults to `Sentry.HackneyClient`, which uses
-      [hackney](https://github.com/benoitc/hackney) as the HTTP client.
+      behaviour. Defaults to `Sentry.FinchClient`, which uses
+      [finch](https://github.com/sneako/finch) as the HTTP client.
       """
     ],
     send_max_attempts: [
@@ -298,30 +298,30 @@ defmodule Sentry.Config do
       The maximum number of attempts to send an event to Sentry.
       """
     ],
-    hackney_opts: [
+    finch_opts: [
       type: :keyword_list,
       default: [pool: :sentry_pool],
       doc: """
-      Options to be passed to `hackney`. Only
-      applied if `:client` is set to `Sentry.HackneyClient`.
+      Options to be passed to `finch`. Only
+      applied if `:client` is set to `Sentry.FinchClient`.
       """
     ],
-    hackney_pool_timeout: [
+    finch_pool_timeout: [
       type: :timeout,
       default: 5000,
       doc: """
       The maximum time to wait for a
       connection to become available. Only applied if `:client` is set to
-      `Sentry.HackneyClient`.
+      `Sentry.FinchClient`.
       """
     ],
-    hackney_pool_max_connections: [
+    finch_pool_max_connections: [
       type: :pos_integer,
       default: 50,
       doc: """
       The maximum number of
       connections to keep in the pool. Only applied if `:client` is set to
-      `Sentry.HackneyClient`.
+      `Sentry.FinchClient`.
       """
     ]
   ]
@@ -545,11 +545,11 @@ defmodule Sentry.Config do
   @spec environment_name() :: String.t() | nil
   def environment_name, do: fetch!(:environment_name)
 
-  @spec max_hackney_connections() :: pos_integer()
-  def max_hackney_connections, do: fetch!(:hackney_pool_max_connections)
+  @spec max_finch_connections() :: pos_integer()
+  def max_finch_connections, do: fetch!(:finch_pool_max_connections)
 
-  @spec hackney_timeout() :: timeout()
-  def hackney_timeout, do: fetch!(:hackney_pool_timeout)
+  @spec finch_timeout() :: timeout()
+  def finch_timeout, do: fetch!(:finch_pool_timeout)
 
   @spec tags() :: map()
   def tags, do: fetch!(:tags)
@@ -590,8 +590,8 @@ defmodule Sentry.Config do
   @spec sample_rate() :: float()
   def sample_rate, do: fetch!(:sample_rate)
 
-  @spec hackney_opts() :: keyword()
-  def hackney_opts, do: fetch!(:hackney_opts)
+  @spec finch_opts() :: keyword()
+  def finch_opts, do: fetch!(:finch_opts)
 
   @spec before_send() :: (Sentry.Event.t() -> Sentry.Event.t()) | {module(), atom()} | nil
   def before_send, do: get(:before_send)

lib/sentry/finch_client.ex

@@ -13,32 +13,47 @@ defmodule Sentry.FinchClient do
 
   Sentry starts its own finch pool called `:sentry_pool`. If you need to set other
   [hackney configuration options](https://github.com/benoitc/hackney/blob/master/doc/hackney.md#request5)
-  for things such as proxies, using your own pool, or response timeouts, the `:hackney_opts`
+  for things such as proxies, using your own pool, or response timeouts, the `:finch_opts`
   configuration is passed directly to hackney for each request. See the configuration
   documentation in the `Sentry` module.
   """
+  @finch_pool_name :sentry_pool
 
   @impl true
   def child_spec do
-    Supervisor.child_spec(
-      {Finch,
-       name: __MODULE__,
-       pools: %{
-         :default => [size: 10]
-       }},
-      id: __MODULE__
-    )
+    if Code.ensure_loaded?(Finch) do
+      case Application.ensure_all_started(:finch) do
+        {:ok, _apps} -> :ok
+        {:error, reason} -> raise "failed to start the :finch application: #{inspect(reason)}"
+      end
+
+      Finch.child_spec(
+        name: __MODULE__,
+        pools: %{
+          :default => [
+            size: Sentry.Config.max_finch_connections(),
+            conn_max_idle_time: Sentry.Config.finch_timeout()
+          ]
+        }
+      )
+    else
+      raise """
+      cannot start the :sentry application because the HTTP client is set to \
+      Sentry.FinchClient (which is the default), but the Finch library is not loaded. \
+      Add :finch to your dependencies to fix this.
+      """
+    end
   end
 
   @impl true
   def post(url, headers, body) do
     request = Finch.build(:post, url, headers, body)
 
-    IO.inspect(request)
-
-    opts = Keyword.put_new([], :pool, :sentry_pool)
+    finch_opts =
+      Sentry.Config.finch_opts()
+      |> Keyword.put_new(:pool, @finch_pool_name)
 
-    case Finch.request(request, __MODULE__, opts) do
+    case Finch.request(request, __MODULE__, finch_opts) do
       {:ok, %Finch.Response{status: status, headers: headers, body: body}} ->
         {:ok, status, headers, body}
 

lib/sentry/hackney_client.ex

@@ -2,7 +2,7 @@ defmodule Sentry.HTTPClient do
   @moduledoc """
   A behaviour for HTTP clients that Sentry can use.
 
-  The default HTTP client is `Sentry.HackneyClient`.
+  The default HTTP client is `Sentry.FinchClient`.
 
   To configure a different HTTP client, implement the `Sentry.HTTPClient` behaviour and
   change the `:client` configuration:
@@ -25,46 +25,45 @@ defmodule Sentry.HTTPClient do
   ## Alternative Clients
 
   Let's look at an example of using an alternative HTTP client. In this example, we'll
-  use [Finch](https://github.com/sneako/finch), a lightweight HTTP client for Elixir.
+  use [Hackney](https://github.com/benoitc/hackney), a lightweight HTTP client for Elixir.
 
-  First, we need to add Finch to our dependencies:
+  First, we need to add Hackney to our dependencies:
 
       # In mix.exs
       defp deps do
         [
           # ...
-          {:finch, "~> 0.16"}
+          {:hackney, "~> 1.8"}
         ]
       end
 
   Then, we need to define a module that implements the `Sentry.HTTPClient` behaviour:
 
-      defmodule MyApp.SentryFinchHTTPClient do
+      defmodule MyApp.SentryHackneyHTTPClient do
         @behaviour Sentry.HTTPClient
 
-        @impl true
-        def child_spec do
-          Supervisor.child_spec({Finch, name: __MODULE__}, id: __MODULE__)
+        # @impl true
+        # def child_spec do
+        #     :hackney_pool.child_spec(
+        #       @hackney_pool_name,
+        #       timeout: Sentry.Config.hackney_timeout(),
+        #       max_connections: Sentry.Config.max_hackney_connections()
+        #     )
+        # end
+
+        # @impl true
+        # def post(url, headers, body) do
+        #   case :hackney.request(:post, url, headers, body) do
+        #     {:ok, _status, _headers, _body} = result -> result
+        #     {:error, _reason} = error -> error
+        #   end
+        # end
         end
 
-        @impl true
-        def post(url, headers, body) do
-          request = Finch.build(:post, url, headers, body)
-
-          case Finch.request(request, __MODULE__) do
-            {:ok, %Finch.Response{status: status, headers: headers, body: body}} ->
-              {:ok, status, headers, body}
-
-            {:error, error} ->
-              {:error, error}
-          end
-        end
-      end
-
   Last, we need to configure Sentry to use our new HTTP client:
 
       config :sentry,
-        client: MyApp.SentryFinchHTTPClient
+        client: Sentry.HackneyClient
 
   ### Umbrella Apps
 

lib/sentry/http_client.ex

@@ -51,7 +51,7 @@ defmodule Sentry.Mixfile do
           "Plug and Phoenix": [Sentry.PlugCapture, Sentry.PlugContext, Sentry.LiveViewHook],
           Loggers: [Sentry.LoggerBackend, Sentry.LoggerHandler],
           "Data Structures": [Sentry.Attachment, Sentry.CheckIn, Sentry.ClientReport],
-          HTTP: [Sentry.HTTPClient, Sentry.HackneyClient],
+          HTTP: [Sentry.HTTPClient, Sentry.FinchClient],
           Interfaces: [~r/^Sentry\.Interfaces/],
           Testing: [Sentry.Test]
         ],
@@ -65,8 +65,8 @@ defmodule Sentry.Mixfile do
         ],
         authors: ["Mitchell Henke", "Jason Stiebs", "Andrea Leopardi"]
       ],
-      xref: [exclude: [:hackney, :hackney_pool, Plug.Conn, :telemetry]],
-      aliases: aliases()
+      xref: [exclude: [Finch, Plug.Conn, :telemetry]],
+      aliases: [aliases()]
     ]
   end
 
@@ -94,7 +94,6 @@ defmodule Sentry.Mixfile do
       {:nimble_ownership, "~> 0.3.0 or ~> 1.0"},
 
       # Optional dependencies
-      {:hackney, "~> 1.8", optional: true},
       {:finch, "~> 0.18.0", optional: true},
       {:jason, "~> 1.1", optional: true},
       {:phoenix, "~> 1.6", optional: true},

mix.exs

@@ -5,7 +5,7 @@ defmodule Mix.Tasks.Sentry.SendTestEventTest do
   import Sentry.TestHelpers
 
   test "prints if :dsn is not set" do
-    put_test_config(dsn: nil, hackney_opts: [], environment_name: "some_env")
+    put_test_config(dsn: nil, finch_opts: [], environment_name: "some_env")
 
     output =
       capture_io(fn ->
@@ -15,7 +15,7 @@ defmodule Mix.Tasks.Sentry.SendTestEventTest do
     assert output =~ """
            Client configuration:
            current environment_name: "some_env"
-           hackney_opts: []
+           finch_opts: []
            """
 
     assert output =~ ~s(Event not sent because the :dsn option is not set)
@@ -35,7 +35,7 @@ defmodule Mix.Tasks.Sentry.SendTestEventTest do
     put_test_config(
       dsn: "http://public:secret@localhost:#{bypass.port}/1",
       environment_name: "test",
-      hackney_opts: []
+      finch_opts: []
     )
 
     output =
@@ -49,7 +49,7 @@ defmodule Mix.Tasks.Sentry.SendTestEventTest do
            public_key: public
            secret_key: secret
            current environment_name: "test"
-           hackney_opts: []
+           finch_opts: []
            """
 
     assert output =~ "Sending test event..."

test/mix/sentry.send_test_event_test.exs

@@ -354,7 +354,7 @@ defmodule Sentry.ClientTest do
       {:error, %Sentry.ClientError{} = error} =
         Client.send_event(event, result: :sync, request_retries: [])
 
-      assert error.reason == {:request_failure, :econnrefused}
+      assert error.reason == {:request_failure, %Mint.TransportError{reason: :econnrefused}}
     end
 
     test "logs an error when unable to encode JSON" do