From bc7659bdf3971d63a3d5785571b9edc99f9de44f Mon Sep 17 00:00:00 2001
From: keatz55 <keatz55@gmail.com>
Date: Fri, 12 Jun 2020 10:01:25 -0600
Subject: [PATCH 1/3] adds telemetry_prefix config w/ tests

---
 lib/tesla/middleware/telemetry.ex        |  37 +++----
 test/tesla/middleware/telemetry_test.exs | 132 ++++++++++++++++++-----
 2 files changed, 118 insertions(+), 51 deletions(-)

diff --git a/lib/tesla/middleware/telemetry.ex b/lib/tesla/middleware/telemetry.ex
index 02e446d7..7f33eb10 100644
--- a/lib/tesla/middleware/telemetry.ex
+++ b/lib/tesla/middleware/telemetry.ex
@@ -1,7 +1,7 @@
 if Code.ensure_loaded?(:telemetry) do
   defmodule Tesla.Middleware.Telemetry do
     @moduledoc """
-    Emits events using the `:telemetry` library to expose instrumentation.
+    Emits events using the `:telemetry` library to expose instrumentation. Those events will use the `:telemetry_prefix` which defaults to `[:tesla]`.
 
     ## Example usage
 
@@ -46,6 +46,8 @@ if Code.ensure_loaded?(:telemetry) do
 
     @behaviour Tesla.Middleware
 
+    @default_telemetry_prefix [:tesla]
+
     @impl Tesla.Middleware
     def call(env, next, _opts) do
       start_time = System.monotonic_time()
@@ -81,40 +83,31 @@ if Code.ensure_loaded?(:telemetry) do
       end
     end
 
+    defp telemetry_prefix() do
+      Application.get_env(:tesla, :telemetry_prefix, @default_telemetry_prefix)
+    end
+
     defp emit_start(metadata) do
-      :telemetry.execute(
-        [:tesla, :request, :start],
-        %{system_time: System.system_time()},
-        metadata
-      )
+      event = telemetry_prefix() ++ [:request, :start]
+      :telemetry.execute(event, %{system_time: System.system_time()}, metadata)
     end
 
     defp emit_stop(duration, metadata) do
-      :telemetry.execute(
-        [:tesla, :request, :stop],
-        %{duration: duration},
-        metadata
-      )
+      event = telemetry_prefix() ++ [:request, :stop]
+      :telemetry.execute(event, %{duration: duration}, metadata)
     end
 
     defp emit_legacy_event(duration, result) do
       if !@disable_legacy_event do
+        event = telemetry_prefix() ++ [:request]
         duration_µs = System.convert_time_unit(duration, :native, :microsecond)
-
-        :telemetry.execute(
-          [:tesla, :request],
-          %{request_time: duration_µs},
-          %{result: result}
-        )
+        :telemetry.execute(event, %{request_time: duration_µs}, %{result: result})
       end
     end
 
     defp emit_exception(duration, metadata) do
-      :telemetry.execute(
-        [:tesla, :request, :exception],
-        %{duration: duration},
-        metadata
-      )
+      event = telemetry_prefix() ++ [:request, :exception]
+      :telemetry.execute(event, %{duration: duration}, metadata)
     end
   end
 end
diff --git a/test/tesla/middleware/telemetry_test.exs b/test/tesla/middleware/telemetry_test.exs
index 6986333a..11353638 100644
--- a/test/tesla/middleware/telemetry_test.exs
+++ b/test/tesla/middleware/telemetry_test.exs
@@ -1,6 +1,8 @@
 defmodule Tesla.Middleware.TelemetryTest do
   use ExUnit.Case, async: true
 
+  @moduletag capture_log: true
+
   defmodule Client do
     use Tesla
 
@@ -26,50 +28,122 @@ defmodule Tesla.Middleware.TelemetryTest do
     :ok
   end
 
-  test "events are all emitted properly" do
-    Enum.each(["/telemetry", "/telemetry_error"], fn path ->
-      :telemetry.attach("start event", [:tesla, :request, :start], &echo_event/4, %{
-        caller: self()
-      })
+  describe "with default config" do
+    test "events are all emitted properly" do
+      Enum.each(["/telemetry", "/telemetry_error"], fn path ->
+        :telemetry.attach("start event", [:tesla, :request, :start], &echo_event/4, %{
+          caller: self()
+        })
 
-      :telemetry.attach("stop event", [:tesla, :request, :stop], &echo_event/4, %{
-        caller: self()
-      })
+        :telemetry.attach("stop event", [:tesla, :request, :stop], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("legacy event", [:tesla, :request], &echo_event/4, %{
+          caller: self()
+        })
+
+        Client.get(path)
+
+        assert_receive {:event, [:tesla, :request, :start], %{system_time: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
 
-      :telemetry.attach("legacy event", [:tesla, :request], &echo_event/4, %{
+        assert_receive {:event, [:tesla, :request, :stop], %{duration: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, [:tesla, :request], %{request_time: time}, %{result: result}}
+      end)
+    end
+
+    test "with an exception raised" do
+      :telemetry.attach("with_exception", [:tesla, :request, :exception], &echo_event/4, %{
         caller: self()
       })
 
-      Client.get(path)
+      assert_raise RuntimeError, fn ->
+        Client.get("/telemetry_exception")
+      end
 
-      assert_receive {:event, [:tesla, :request, :start], %{system_time: time},
-                      %{env: %Tesla.Env{url: path, method: :get}}}
+      assert_receive {:event, [:tesla, :request, :exception], %{duration: time},
+                      %{
+                        kind: kind,
+                        reason: reason,
+                        stacktrace: stacktrace
+                      }}
+    end
+  end
 
-      assert_receive {:event, [:tesla, :request, :stop], %{duration: time},
-                      %{env: %Tesla.Env{url: path, method: :get}}}
+  describe "with :telemetry_prefix config" do
+    setup [:telemetry_prefix]
 
-      assert_receive {:event, [:tesla, :request], %{request_time: time}, %{result: result}}
-    end)
-  end
+    @telemetry_prefix [:custom, :prefix]
 
-  test "with an exception raised" do
-    :telemetry.attach("with_exception", [:tesla, :request, :exception], &echo_event/4, %{
-      caller: self()
-    })
+    test "events are all emitted properly" do
+      Enum.each(["/telemetry", "/telemetry_error"], fn path ->
+        :telemetry.attach(
+          "start event",
+          @telemetry_prefix ++ [:request, :start],
+          &echo_event/4,
+          %{
+            caller: self()
+          }
+        )
 
-    assert_raise RuntimeError, fn ->
-      Client.get("/telemetry_exception")
+        :telemetry.attach("stop event", @telemetry_prefix ++ [:request, :stop], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("legacy event", @telemetry_prefix ++ [:request], &echo_event/4, %{
+          caller: self()
+        })
+
+        Client.get(path)
+
+        assert_receive {:event, @telemetry_prefix ++ [:request, :start], %{system_time: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, @telemetry_prefix ++ [:request, :stop], %{duration: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, @telemetry_prefix ++ [:request], %{request_time: time},
+                        %{result: result}}
+      end)
     end
 
-    assert_receive {:event, [:tesla, :request, :exception], %{duration: time},
-                    %{
-                      kind: kind,
-                      reason: reason,
-                      stacktrace: stacktrace
-                    }}
+    test "with an exception raised" do
+      :telemetry.attach(
+        "with_exception",
+        [:custom, :prefix, :request, :exception],
+        &echo_event/4,
+        %{
+          caller: self()
+        }
+      )
+
+      assert_raise RuntimeError, fn ->
+        Client.get("/telemetry_exception")
+      end
+
+      assert_receive {:event, @telemetry_prefix ++ [:request, :exception], %{duration: time},
+                      %{
+                        kind: kind,
+                        reason: reason,
+                        stacktrace: stacktrace
+                      }}
+    end
   end
 
   def echo_event(event, measurements, metadata, config) do
     send(config.caller, {:event, event, measurements, metadata})
   end
+
+  defp telemetry_prefix(_) do
+    Application.put_env(:tesla, :telemetry_prefix, [:custom, :prefix])
+
+    on_exit(fn ->
+      Application.delete_env(:tesla, :telemetry_prefix)
+    end)
+
+    :ok
+  end
 end

From ac2e14e5425d9501e8ad142109b501cde2311c3e Mon Sep 17 00:00:00 2001
From: keatz55 <keatz55@gmail.com>
Date: Fri, 12 Jun 2020 11:47:58 -0600
Subject: [PATCH 2/3] adds better configuration options and docs

---
 lib/tesla/middleware/telemetry.ex        |  69 +++++---
 test/tesla/middleware/telemetry_test.exs | 193 ++++++++++++++++++-----
 2 files changed, 202 insertions(+), 60 deletions(-)

diff --git a/lib/tesla/middleware/telemetry.ex b/lib/tesla/middleware/telemetry.ex
index 7f33eb10..aa4af6f6 100644
--- a/lib/tesla/middleware/telemetry.ex
+++ b/lib/tesla/middleware/telemetry.ex
@@ -1,7 +1,7 @@
 if Code.ensure_loaded?(:telemetry) do
   defmodule Tesla.Middleware.Telemetry do
     @moduledoc """
-    Emits events using the `:telemetry` library to expose instrumentation. Those events will use the `:telemetry_prefix` which defaults to `[:tesla]`.
+    Emits events using the `:telemetry` library to expose instrumentation.
 
     ## Example usage
 
@@ -18,6 +18,34 @@ if Code.ensure_loaded?(:telemetry) do
     end)
     ```
 
+    ## Options
+    - `:telemetry_prefix` - replaces default `[:tesla]` with desired Telemetry event prefix (see below)
+
+    ## Custom Telemetry Prefix
+
+    All events will use a `:telemetry_prefix` which defaults to `[:tesla]`.
+
+    You can customize events by providing your own `:telemetry_prefix` locally:
+
+    ```
+    defmodule MyClient do
+      use Tesla
+
+      plug Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
+
+    end
+
+    :telemetry.attach("my-tesla-telemetry", [:custom, :prefix, :request, :stop], fn event, measurements, meta, config ->
+      # Do something with the event
+    end)
+    ```
+
+    You can configure `:telemetry_prefix` globally in your config, but if set the `:telemetry_prefix` option will override:
+
+    ```
+    config :tesla, Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
+    ```
+
     ## Telemetry Events
 
     * `[:tesla, :request, :start]` - emitted at the beginning of the request.
@@ -49,10 +77,11 @@ if Code.ensure_loaded?(:telemetry) do
     @default_telemetry_prefix [:tesla]
 
     @impl Tesla.Middleware
-    def call(env, next, _opts) do
+    def call(env, next, opts) do
       start_time = System.monotonic_time()
+      prefix = telemetry_prefix(opts)
 
-      emit_start(%{env: env})
+      emit_start(%{env: env}, prefix)
 
       try do
         Tesla.run(env, next)
@@ -61,52 +90,56 @@ if Code.ensure_loaded?(:telemetry) do
           stacktrace = System.stacktrace()
           duration = System.monotonic_time() - start_time
 
-          emit_exception(duration, %{kind: kind, reason: reason, stacktrace: stacktrace})
+          emit_exception(duration, %{kind: kind, reason: reason, stacktrace: stacktrace}, prefix)
 
           :erlang.raise(kind, reason, stacktrace)
       else
         {:ok, env} = result ->
           duration = System.monotonic_time() - start_time
 
-          emit_stop(duration, %{env: env})
-          emit_legacy_event(duration, result)
+          emit_stop(duration, %{env: env}, prefix)
+          emit_legacy_event(duration, result, prefix)
 
           result
 
         {:error, reason} = result ->
           duration = System.monotonic_time() - start_time
 
-          emit_stop(duration, %{env: env, error: reason})
-          emit_legacy_event(duration, result)
+          emit_stop(duration, %{env: env, error: reason}, prefix)
+          emit_legacy_event(duration, result, prefix)
 
           result
       end
     end
 
-    defp telemetry_prefix() do
-      Application.get_env(:tesla, :telemetry_prefix, @default_telemetry_prefix)
+    defp config, do: Application.get_env(:tesla, __MODULE__, [])
+
+    defp telemetry_prefix(opts) do
+      with nil <- Keyword.get(opts, :telemetry_prefix) do
+        Keyword.get(config(), :telemetry_prefix, @default_telemetry_prefix)
+      end
     end
 
-    defp emit_start(metadata) do
-      event = telemetry_prefix() ++ [:request, :start]
+    defp emit_start(metadata, prefix) do
+      event = prefix ++ [:request, :start]
       :telemetry.execute(event, %{system_time: System.system_time()}, metadata)
     end
 
-    defp emit_stop(duration, metadata) do
-      event = telemetry_prefix() ++ [:request, :stop]
+    defp emit_stop(duration, metadata, prefix) do
+      event = prefix ++ [:request, :stop]
       :telemetry.execute(event, %{duration: duration}, metadata)
     end
 
-    defp emit_legacy_event(duration, result) do
+    defp emit_legacy_event(duration, result, prefix) do
       if !@disable_legacy_event do
-        event = telemetry_prefix() ++ [:request]
+        event = prefix ++ [:request]
         duration_µs = System.convert_time_unit(duration, :native, :microsecond)
         :telemetry.execute(event, %{request_time: duration_µs}, %{result: result})
       end
     end
 
-    defp emit_exception(duration, metadata) do
-      event = telemetry_prefix() ++ [:request, :exception]
+    defp emit_exception(duration, metadata, prefix) do
+      event = prefix ++ [:request, :exception]
       :telemetry.execute(event, %{duration: duration}, metadata)
     end
   end
diff --git a/test/tesla/middleware/telemetry_test.exs b/test/tesla/middleware/telemetry_test.exs
index 11353638..95773b7e 100644
--- a/test/tesla/middleware/telemetry_test.exs
+++ b/test/tesla/middleware/telemetry_test.exs
@@ -28,7 +28,7 @@ defmodule Tesla.Middleware.TelemetryTest do
     :ok
   end
 
-  describe "with default config" do
+  describe "Telemetry" do
     test "events are all emitted properly" do
       Enum.each(["/telemetry", "/telemetry_error"], fn path ->
         :telemetry.attach("start event", [:tesla, :request, :start], &echo_event/4, %{
@@ -39,9 +39,7 @@ defmodule Tesla.Middleware.TelemetryTest do
           caller: self()
         })
 
-        :telemetry.attach("legacy event", [:tesla, :request], &echo_event/4, %{
-          caller: self()
-        })
+        :telemetry.attach("legacy event", [:tesla, :request], &echo_event/4, %{caller: self()})
 
         Client.get(path)
 
@@ -65,47 +63,44 @@ defmodule Tesla.Middleware.TelemetryTest do
       end
 
       assert_receive {:event, [:tesla, :request, :exception], %{duration: time},
-                      %{
-                        kind: kind,
-                        reason: reason,
-                        stacktrace: stacktrace
-                      }}
+                      %{kind: kind, reason: reason, stacktrace: stacktrace}}
     end
   end
 
   describe "with :telemetry_prefix config" do
-    setup [:telemetry_prefix]
+    setup do
+      Application.put_env(:tesla, Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix])
+
+      on_exit(fn ->
+        Application.delete_env(:tesla, Tesla.Middleware.Telemetry)
+      end)
 
-    @telemetry_prefix [:custom, :prefix]
+      :ok
+    end
 
     test "events are all emitted properly" do
       Enum.each(["/telemetry", "/telemetry_error"], fn path ->
-        :telemetry.attach(
-          "start event",
-          @telemetry_prefix ++ [:request, :start],
-          &echo_event/4,
-          %{
-            caller: self()
-          }
-        )
-
-        :telemetry.attach("stop event", @telemetry_prefix ++ [:request, :stop], &echo_event/4, %{
+        :telemetry.attach("start event", [:custom, :prefix, :request, :start], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("stop event", [:custom, :prefix, :request, :stop], &echo_event/4, %{
           caller: self()
         })
 
-        :telemetry.attach("legacy event", @telemetry_prefix ++ [:request], &echo_event/4, %{
+        :telemetry.attach("legacy event", [:custom, :prefix, :request], &echo_event/4, %{
           caller: self()
         })
 
         Client.get(path)
 
-        assert_receive {:event, @telemetry_prefix ++ [:request, :start], %{system_time: time},
+        assert_receive {:event, [:custom, :prefix, :request, :start], %{system_time: time},
                         %{env: %Tesla.Env{url: path, method: :get}}}
 
-        assert_receive {:event, @telemetry_prefix ++ [:request, :stop], %{duration: time},
+        assert_receive {:event, [:custom, :prefix, :request, :stop], %{duration: time},
                         %{env: %Tesla.Env{url: path, method: :get}}}
 
-        assert_receive {:event, @telemetry_prefix ++ [:request], %{request_time: time},
+        assert_receive {:event, [:custom, :prefix, :request], %{request_time: time},
                         %{result: result}}
       end)
     end
@@ -115,35 +110,149 @@ defmodule Tesla.Middleware.TelemetryTest do
         "with_exception",
         [:custom, :prefix, :request, :exception],
         &echo_event/4,
-        %{
-          caller: self()
-        }
+        %{caller: self()}
       )
 
       assert_raise RuntimeError, fn ->
         Client.get("/telemetry_exception")
       end
 
-      assert_receive {:event, @telemetry_prefix ++ [:request, :exception], %{duration: time},
-                      %{
-                        kind: kind,
-                        reason: reason,
-                        stacktrace: stacktrace
-                      }}
+      assert_receive {:event, [:custom, :prefix, :request, :exception], %{duration: time},
+                      %{kind: kind, reason: reason, stacktrace: stacktrace}}
     end
   end
 
-  def echo_event(event, measurements, metadata, config) do
-    send(config.caller, {:event, event, measurements, metadata})
+  describe "with :telemetry_prefix option" do
+    defmodule ClientWithTelemetryPrefix do
+      use Tesla
+
+      plug Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
+
+      adapter fn env ->
+        case env.url do
+          "/telemetry" -> {:ok, env}
+          "/telemetry_error" -> {:error, :econnrefused}
+          "/telemetry_exception" -> raise "some exception"
+        end
+      end
+    end
+
+    test "events are all emitted properly" do
+      Enum.each(["/telemetry", "/telemetry_error"], fn path ->
+        :telemetry.attach("start event", [:custom, :prefix, :request, :start], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("stop event", [:custom, :prefix, :request, :stop], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("legacy event", [:custom, :prefix, :request], &echo_event/4, %{
+          caller: self()
+        })
+
+        ClientWithTelemetryPrefix.get(path)
+
+        assert_receive {:event, [:custom, :prefix, :request, :start], %{system_time: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, [:custom, :prefix, :request, :stop], %{duration: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, [:custom, :prefix, :request], %{request_time: time},
+                        %{result: result}}
+      end)
+    end
+
+    test "with an exception raised" do
+      :telemetry.attach(
+        "with_exception",
+        [:custom, :prefix, :request, :exception],
+        &echo_event/4,
+        %{caller: self()}
+      )
+
+      assert_raise RuntimeError, fn ->
+        ClientWithTelemetryPrefix.get("/telemetry_exception")
+      end
+
+      assert_receive {:event, [:custom, :prefix, :request, :exception], %{duration: time},
+                      %{kind: kind, reason: reason, stacktrace: stacktrace}}
+    end
   end
 
-  defp telemetry_prefix(_) do
-    Application.put_env(:tesla, :telemetry_prefix, [:custom, :prefix])
+  describe "with :telemetry_prefix config and option override" do
+    setup do
+      Application.put_env(:tesla, Tesla.Middleware.Telemetry,
+        telemetry_prefix: [:different, :prefix]
+      )
 
-    on_exit(fn ->
-      Application.delete_env(:tesla, :telemetry_prefix)
-    end)
+      on_exit(fn ->
+        Application.delete_env(:tesla, Tesla.Middleware.Telemetry)
+      end)
 
-    :ok
+      :ok
+    end
+
+    defmodule ClientConfigWithTelemetryPrefix do
+      use Tesla
+
+      plug Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
+
+      adapter fn env ->
+        case env.url do
+          "/telemetry" -> {:ok, env}
+          "/telemetry_error" -> {:error, :econnrefused}
+          "/telemetry_exception" -> raise "some exception"
+        end
+      end
+    end
+
+    test "events are all emitted properly" do
+      Enum.each(["/telemetry", "/telemetry_error"], fn path ->
+        :telemetry.attach("start event", [:custom, :prefix, :request, :start], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("stop event", [:custom, :prefix, :request, :stop], &echo_event/4, %{
+          caller: self()
+        })
+
+        :telemetry.attach("legacy event", [:custom, :prefix, :request], &echo_event/4, %{
+          caller: self()
+        })
+
+        ClientConfigWithTelemetryPrefix.get(path)
+
+        assert_receive {:event, [:custom, :prefix, :request, :start], %{system_time: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, [:custom, :prefix, :request, :stop], %{duration: time},
+                        %{env: %Tesla.Env{url: path, method: :get}}}
+
+        assert_receive {:event, [:custom, :prefix, :request], %{request_time: time},
+                        %{result: result}}
+      end)
+    end
+
+    test "with an exception raised" do
+      :telemetry.attach(
+        "with_exception",
+        [:custom, :prefix, :request, :exception],
+        &echo_event/4,
+        %{caller: self()}
+      )
+
+      assert_raise RuntimeError, fn ->
+        ClientConfigWithTelemetryPrefix.get("/telemetry_exception")
+      end
+
+      assert_receive {:event, [:custom, :prefix, :request, :exception], %{duration: time},
+                      %{kind: kind, reason: reason, stacktrace: stacktrace}}
+    end
+  end
+
+  def echo_event(event, measurements, metadata, config) do
+    send(config.caller, {:event, event, measurements, metadata})
   end
 end

From 619f19cece433539db325ac68fb49a73f4f29aec Mon Sep 17 00:00:00 2001
From: keatz55 <keatz55@gmail.com>
Date: Mon, 15 Jun 2020 10:06:17 -0600
Subject: [PATCH 3/3] makes requested changes

---
 lib/tesla/middleware/telemetry.ex        |  28 ++---
 test/tesla/middleware/telemetry_test.exs | 136 +----------------------
 2 files changed, 12 insertions(+), 152 deletions(-)

diff --git a/lib/tesla/middleware/telemetry.ex b/lib/tesla/middleware/telemetry.ex
index aa4af6f6..42a54984 100644
--- a/lib/tesla/middleware/telemetry.ex
+++ b/lib/tesla/middleware/telemetry.ex
@@ -19,19 +19,19 @@ if Code.ensure_loaded?(:telemetry) do
     ```
 
     ## Options
-    - `:telemetry_prefix` - replaces default `[:tesla]` with desired Telemetry event prefix (see below)
+    - `:prefix` - replaces default `[:tesla]` with desired Telemetry event prefix (see below)
 
-    ## Custom Telemetry Prefix
+    ## Custom Prefix
 
-    All events will use a `:telemetry_prefix` which defaults to `[:tesla]`.
+    All events will use a `:prefix` which defaults to `[:tesla]`.
 
-    You can customize events by providing your own `:telemetry_prefix` locally:
+    You can customize events by providing your own `:prefix` locally:
 
     ```
     defmodule MyClient do
       use Tesla
 
-      plug Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
+      plug Tesla.Middleware.Telemetry, prefix: [:custom, :prefix]
 
     end
 
@@ -40,12 +40,6 @@ if Code.ensure_loaded?(:telemetry) do
     end)
     ```
 
-    You can configure `:telemetry_prefix` globally in your config, but if set the `:telemetry_prefix` option will override:
-
-    ```
-    config :tesla, Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
-    ```
-
     ## Telemetry Events
 
     * `[:tesla, :request, :start]` - emitted at the beginning of the request.
@@ -74,12 +68,12 @@ if Code.ensure_loaded?(:telemetry) do
 
     @behaviour Tesla.Middleware
 
-    @default_telemetry_prefix [:tesla]
+    @default_prefix [:tesla]
 
     @impl Tesla.Middleware
     def call(env, next, opts) do
       start_time = System.monotonic_time()
-      prefix = telemetry_prefix(opts)
+      prefix = Keyword.get(opts, :prefix, @default_prefix)
 
       emit_start(%{env: env}, prefix)
 
@@ -112,14 +106,6 @@ if Code.ensure_loaded?(:telemetry) do
       end
     end
 
-    defp config, do: Application.get_env(:tesla, __MODULE__, [])
-
-    defp telemetry_prefix(opts) do
-      with nil <- Keyword.get(opts, :telemetry_prefix) do
-        Keyword.get(config(), :telemetry_prefix, @default_telemetry_prefix)
-      end
-    end
-
     defp emit_start(metadata, prefix) do
       event = prefix ++ [:request, :start]
       :telemetry.execute(event, %{system_time: System.system_time()}, metadata)
diff --git a/test/tesla/middleware/telemetry_test.exs b/test/tesla/middleware/telemetry_test.exs
index 95773b7e..26e8ada3 100644
--- a/test/tesla/middleware/telemetry_test.exs
+++ b/test/tesla/middleware/telemetry_test.exs
@@ -67,137 +67,11 @@ defmodule Tesla.Middleware.TelemetryTest do
     end
   end
 
-  describe "with :telemetry_prefix config" do
-    setup do
-      Application.put_env(:tesla, Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix])
-
-      on_exit(fn ->
-        Application.delete_env(:tesla, Tesla.Middleware.Telemetry)
-      end)
-
-      :ok
-    end
-
-    test "events are all emitted properly" do
-      Enum.each(["/telemetry", "/telemetry_error"], fn path ->
-        :telemetry.attach("start event", [:custom, :prefix, :request, :start], &echo_event/4, %{
-          caller: self()
-        })
-
-        :telemetry.attach("stop event", [:custom, :prefix, :request, :stop], &echo_event/4, %{
-          caller: self()
-        })
-
-        :telemetry.attach("legacy event", [:custom, :prefix, :request], &echo_event/4, %{
-          caller: self()
-        })
-
-        Client.get(path)
-
-        assert_receive {:event, [:custom, :prefix, :request, :start], %{system_time: time},
-                        %{env: %Tesla.Env{url: path, method: :get}}}
-
-        assert_receive {:event, [:custom, :prefix, :request, :stop], %{duration: time},
-                        %{env: %Tesla.Env{url: path, method: :get}}}
-
-        assert_receive {:event, [:custom, :prefix, :request], %{request_time: time},
-                        %{result: result}}
-      end)
-    end
-
-    test "with an exception raised" do
-      :telemetry.attach(
-        "with_exception",
-        [:custom, :prefix, :request, :exception],
-        &echo_event/4,
-        %{caller: self()}
-      )
-
-      assert_raise RuntimeError, fn ->
-        Client.get("/telemetry_exception")
-      end
-
-      assert_receive {:event, [:custom, :prefix, :request, :exception], %{duration: time},
-                      %{kind: kind, reason: reason, stacktrace: stacktrace}}
-    end
-  end
-
-  describe "with :telemetry_prefix option" do
-    defmodule ClientWithTelemetryPrefix do
-      use Tesla
-
-      plug Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
-
-      adapter fn env ->
-        case env.url do
-          "/telemetry" -> {:ok, env}
-          "/telemetry_error" -> {:error, :econnrefused}
-          "/telemetry_exception" -> raise "some exception"
-        end
-      end
-    end
-
-    test "events are all emitted properly" do
-      Enum.each(["/telemetry", "/telemetry_error"], fn path ->
-        :telemetry.attach("start event", [:custom, :prefix, :request, :start], &echo_event/4, %{
-          caller: self()
-        })
-
-        :telemetry.attach("stop event", [:custom, :prefix, :request, :stop], &echo_event/4, %{
-          caller: self()
-        })
-
-        :telemetry.attach("legacy event", [:custom, :prefix, :request], &echo_event/4, %{
-          caller: self()
-        })
-
-        ClientWithTelemetryPrefix.get(path)
-
-        assert_receive {:event, [:custom, :prefix, :request, :start], %{system_time: time},
-                        %{env: %Tesla.Env{url: path, method: :get}}}
-
-        assert_receive {:event, [:custom, :prefix, :request, :stop], %{duration: time},
-                        %{env: %Tesla.Env{url: path, method: :get}}}
-
-        assert_receive {:event, [:custom, :prefix, :request], %{request_time: time},
-                        %{result: result}}
-      end)
-    end
-
-    test "with an exception raised" do
-      :telemetry.attach(
-        "with_exception",
-        [:custom, :prefix, :request, :exception],
-        &echo_event/4,
-        %{caller: self()}
-      )
-
-      assert_raise RuntimeError, fn ->
-        ClientWithTelemetryPrefix.get("/telemetry_exception")
-      end
-
-      assert_receive {:event, [:custom, :prefix, :request, :exception], %{duration: time},
-                      %{kind: kind, reason: reason, stacktrace: stacktrace}}
-    end
-  end
-
-  describe "with :telemetry_prefix config and option override" do
-    setup do
-      Application.put_env(:tesla, Tesla.Middleware.Telemetry,
-        telemetry_prefix: [:different, :prefix]
-      )
-
-      on_exit(fn ->
-        Application.delete_env(:tesla, Tesla.Middleware.Telemetry)
-      end)
-
-      :ok
-    end
-
-    defmodule ClientConfigWithTelemetryPrefix do
+  describe "with :prefix" do
+    defmodule ClientWithPrefix do
       use Tesla
 
-      plug Tesla.Middleware.Telemetry, telemetry_prefix: [:custom, :prefix]
+      plug Tesla.Middleware.Telemetry, prefix: [:custom, :prefix]
 
       adapter fn env ->
         case env.url do
@@ -222,7 +96,7 @@ defmodule Tesla.Middleware.TelemetryTest do
           caller: self()
         })
 
-        ClientConfigWithTelemetryPrefix.get(path)
+        ClientWithPrefix.get(path)
 
         assert_receive {:event, [:custom, :prefix, :request, :start], %{system_time: time},
                         %{env: %Tesla.Env{url: path, method: :get}}}
@@ -244,7 +118,7 @@ defmodule Tesla.Middleware.TelemetryTest do
       )
 
       assert_raise RuntimeError, fn ->
-        ClientConfigWithTelemetryPrefix.get("/telemetry_exception")
+        ClientWithPrefix.get("/telemetry_exception")
       end
 
       assert_receive {:event, [:custom, :prefix, :request, :exception], %{duration: time},