Switch HTTP Client from Hackney to Finch

README.md

@@ -20,15 +20,16 @@ This is the official Sentry SDK for [Sentry].
 
 To use Sentry in your project, add it as a dependency in your `mix.exs` file.
 
-Sentry does not install a JSON library nor an HTTP client by itself. Sentry will default to the [built-in `JSON`](https://hexdocs.pm/elixir/JSON.html) for JSON and [Hackney] for HTTP requests, but can be configured to use other ones. To use the default ones, do:
+Sentry does not install a JSON library nor an HTTP client by itself. Sentry will default to the [built-in `JSON`](https://hexdocs.pm/elixir/JSON.html) for JSON and [Finch] for HTTP requests, but can be configured to use other ones. To use the default ones, do:
 
 ```elixir
 defp deps do
   [
     # ...
 
     {:sentry, "~> 11.0"},
-    {:hackney, "~> 1.20"}
+    {:jason, "~> 1.4"},
+    {:finch, "~> 0.17.0"}
   ]
 end
 ```
@@ -203,7 +204,7 @@ Licensed under the MIT license, see [`LICENSE`](./LICENSE).
 
 [Sentry]: http://sentry.io/
 [Jason]: https://github.com/michalmuskala/jason
-[Hackney]: https://github.com/benoitc/hackney
+[Finch]: https://github.com/sneako/finch
 [Bypass]: https://github.com/PSPDFKit-labs/bypass
 [docs]: https://hexdocs.pm/sentry/readme.html
 [logger-handlers]: https://www.erlang.org/doc/apps/kernel/logger_chapter#handlers

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_request_opts: [receive_timeout: 50],
     send_result: :sync,
     send_max_attempts: 1,
     dedup_events: false,
@@ -34,3 +34,6 @@ if config_env() == :test do
 end
 
 config :phoenix, :json_library, if(Code.ensure_loaded?(JSON), do: JSON, else: Jason)
+
+config :sentry,
+  client: Sentry.FinchClient

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 pool options: #{inspect(Config.finch_pool_opts(), pretty: true)}\n")
   end
 
   defp send_event(opts) do

lib/sentry/application.ex

@@ -18,7 +18,8 @@ defmodule Sentry.Application do
     http_client = Keyword.fetch!(config, :client)
 
     maybe_http_client_spec =
-      if Code.ensure_loaded?(http_client) and function_exported?(http_client, :child_spec, 0) do
+      if {:module, http_client} == Code.ensure_loaded(http_client) and
+           function_exported?(http_client, :child_spec, 0) do
         [http_client.child_spec()]
       else
         []

lib/sentry/config.ex

@@ -352,11 +352,12 @@ 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.
+      *The default changed from Hackney to Finch in v10.11.0*.
       """
     ],
     send_max_attempts: [
@@ -366,32 +367,67 @@ defmodule Sentry.Config do
       The maximum number of attempts to send an event to Sentry.
       """
     ],
-    hackney_opts: [
+    finch_pool_opts: [
       type: :keyword_list,
-      default: [pool: :sentry_pool],
+      default: [size: 50],
       doc: """
-      Options to be passed to `hackney`. Only
-      applied if `:client` is set to `Sentry.HackneyClient`.
+      Pool options to be passed to `Finch.start_link/1`. These options control
+      the connection pool behavior. Only applied if `:client` is set to
+      `Sentry.FinchClient`. See [Finch documentation](https://hexdocs.pm/finch/0.17.0/Finch.html#start_link/1)
+      for available options.
       """
     ],
-    hackney_pool_timeout: [
-      type: :timeout,
-      default: 5000,
+    finch_request_opts: [
+      type: :keyword_list,
+      default: [receive_timeout: 5000],
       doc: """
-      The maximum time to wait for a
-      connection to become available. Only applied if `:client` is set to
-      `Sentry.HackneyClient`.
+      Request options to be passed to `Finch.request/4`. These options control
+      individual request behavior. Only applied if `:client` is set to
+      `Sentry.FinchClient`. See [Finch documentation](https://hexdocs.pm/finch/0.17.0/Finch.html#request/4)
+      for available options.
       """
     ],
-    hackney_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`.
-      """
-    ]
+    hackney_opts:
+      [
+        type: :keyword_list,
+        default: [pool: :sentry_pool],
+        doc: """
+        Options to be passed to `hackney`. Only
+        applied if `:client` is set to `Sentry.HackneyClient`.
+        """
+      ] ++
+        if(Mix.env() == :test,
+          do: [],
+          else: [deprecated: "Use Finch as the default HTTP client instead."]
+        ),
+    hackney_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`.
+        """
+      ] ++
+        if(Mix.env() == :test,
+          do: [],
+          else: [deprecated: "Use Finch as the default HTTP client instead."]
+        ),
+    hackney_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`.
+        """
+      ] ++
+        if(Mix.env() == :test,
+          do: [],
+          else: [deprecated: "Use Finch as the default HTTP client instead."]
+        )
   ]
 
   source_code_context_opts_schema = [
@@ -668,6 +704,12 @@ defmodule Sentry.Config do
   @spec traces_sampler() :: traces_sampler_function() | nil
   def traces_sampler, do: get(:traces_sampler)
 
+  @spec finch_pool_opts() :: keyword()
+  def finch_pool_opts, do: fetch!(:finch_pool_opts)
+
+  @spec finch_request_opts() :: keyword()
+  def finch_request_opts, do: fetch!(:finch_request_opts)
+
   @spec hackney_opts() :: keyword()
   def hackney_opts, do: fetch!(:hackney_opts)
 

lib/sentry/finch_client.ex

@@ -0,0 +1,54 @@
+defmodule Sentry.FinchClient do
+  @behaviour Sentry.HTTPClient
+
+  @moduledoc """
+  The built-in HTTP client.
+
+  This client implements the `Sentry.HTTPClient` behaviour.
+  It's based on the [Finch](https://github.com/sneako/finch) Elixir HTTP client,
+  which is an *optional dependency* of this library. If you wish to use another
+  HTTP client, you'll have to implement your own `Sentry.HTTPClient`. See the
+  documentation for `Sentry.HTTPClient` for more information.
+  Finch is built on top of [NimblePool](https://github.com/dashbitco/nimble_pool). If you need to set other pool configuration options,
+  see ["Pool Configuration Options"](https://hexdocs.pm/finch/Finch.html#start_link/1-pool-configuration-options)
+  in the Finch documentation for details on the possible map values.
+  [finch configuration options](https://hexdocs.pm/finch/Finch.html#start_link/1-pool-configuration-options)
+  """
+  @moduledoc since: "10.11.0"
+
+  @impl true
+  def child_spec do
+    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 => Sentry.Config.finch_pool_opts()
+        }
+      )
+    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)
+
+    case Finch.request(request, __MODULE__, Sentry.Config.finch_request_opts()) do
+      {:ok, %{status: status, headers: headers, body: body}} ->
+        {:ok, status, headers, body}
+
+      {:error, error} ->
+        {:error, error}
+    end
+  end
+end

lib/sentry/http_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` since v10.11.0 (it was based on Hackney before that).
 
   To configure a different HTTP client, implement the `Sentry.HTTPClient` behaviour and
   change the `:client` configuration:

mix.exs

@@ -50,7 +50,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, Sentry.HackneyClient],
           Interfaces: [~r/^Sentry\.Interfaces/],
           Testing: [Sentry.Test]
         ],
@@ -64,7 +64,7 @@ defmodule Sentry.Mixfile do
         ],
         authors: ["Mitchell Henke", "Jason Stiebs", "Andrea Leopardi"]
       ],
-      xref: [exclude: [:hackney, :hackney_pool, Plug.Conn, :telemetry]],
+      xref: [exclude: [Finch, :hackney, :hackney_pool, Plug.Conn, :telemetry]],
       aliases: aliases()
     ]
   end
@@ -101,6 +101,7 @@ defmodule Sentry.Mixfile do
 
       # Optional dependencies
       {:hackney, "~> 1.8", optional: true},
+      {:finch, "~> 0.19.0"},
       {:jason, "~> 1.1", optional: true},
       {:phoenix, "~> 1.6", optional: true},
       {:phoenix_live_view, "~> 0.20 or ~> 1.0", optional: true},

test/logger_backend_test.exs

@@ -136,7 +136,9 @@ defmodule Sentry.LoggerBackendTest do
 
     start_supervised!(Sentry.ExamplePlugApplication, restart: :temporary)
 
-    :hackney.get("http://127.0.0.1:8003/error_route", [], "", [])
+    Finch.build(:get, "http://127.0.0.1:8003/error_route", [], "", [])
+    |> Finch.request(Sentry.FinchClient)
+
     assert_receive {^ref, _event}, 1000
     assert_receive {^ref, _event}, 1000
   after
@@ -150,7 +152,9 @@ defmodule Sentry.LoggerBackendTest do
 
     start_supervised!({Sentry.ExamplePlugApplication, server: :bandit}, restart: :temporary)
 
-    :hackney.get("http://127.0.0.1:8003/error_route", [], "", [])
+    Finch.build(:get, "http://127.0.0.1:8003/error_route", [], "", [])
+    |> Finch.request(Sentry.FinchClient)
+
     assert_receive {^ref, _event}, 1000
     assert_receive {^ref, _event}, 1000
   after

test/mix/sentry.send_test_event_test.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_pool_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 pool options: []
            """
 
     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_pool_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 pool options: []
            """
 
     assert output =~ "Sending test event..."

test/sentry/client_test.exs

@@ -356,7 +356,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

test/sentry/logger_handler_test.exs

@@ -88,7 +88,10 @@ defmodule Sentry.LoggerHandlerTest do
 
     test "TODO", %{sender_ref: ref} do
       start_supervised!(Sentry.ExamplePlugApplication, restart: :temporary)
-      :hackney.get("http://127.0.0.1:8003/error_route", [], "", [])
+
+      Finch.build(:get, "http://127.0.0.1:8003/error_route", [], "", [])
+      |> Finch.request(Sentry.FinchClient)
+
       assert_receive {^ref, event}, 1000
       assert event.original_exception == %RuntimeError{message: "Error"}
     end
@@ -98,7 +101,8 @@ defmodule Sentry.LoggerHandlerTest do
          %{sender_ref: ref} do
       start_supervised!(Sentry.ExamplePlugApplication, restart: :temporary)
 
-      :hackney.get("http://127.0.0.1:8003/error_route", [], "", [])
+      Finch.build(:get, "http://127.0.0.1:8003/error_route", [], "", [])
+      |> Finch.request(Sentry.FinchClient)
 
       assert_receive {^ref, event}, 1000
       assert event.original_exception == %RuntimeError{message: "Error"}
@@ -112,7 +116,8 @@ defmodule Sentry.LoggerHandlerTest do
          %{sender_ref: ref} do
       start_supervised!({Sentry.ExamplePlugApplication, server: :bandit}, restart: :temporary)
 
-      :hackney.get("http://127.0.0.1:8003/error_route", [], "", [])
+      Finch.build(:get, "http://127.0.0.1:8003/error_route", [], "", [])
+      |> Finch.request(Sentry.FinchClient)
 
       assert_receive {^ref, _event}, 1000
       assert_receive {^ref, _event}, 1000
@@ -687,7 +692,7 @@ defmodule Sentry.LoggerHandlerTest do
     put_test_config(
       dsn: "http://public:secret@localhost:#{bypass.port}/1",
       dedup_events: false,
-      hackney_opts: [recv_timeout: 500, pool: :sentry_pool]
+      finch_request_opts: [receive_timeout: 500]
     )
 
     Bypass.expect(bypass, fn conn ->