defmodule Tesla.Middleware.OpenTelemetryTest do use ExUnit.Case require Record for {name, spec} <- Record.extract_all(from_lib: "opentelemetry/include/otel_span.hrl") do Record.defrecord(name, spec) end for {name, spec} <- Record.extract_all(from_lib: "opentelemetry_api/include/opentelemetry.hrl") do Record.defrecord(name, spec) end setup do bypass = Bypass.open() :application.stop(:opentelemetry) :application.set_env(:opentelemetry, :tracer, :otel_tracer_default) :application.set_env(:opentelemetry, :processors, [ {:otel_batch_processor, %{scheduled_delay_ms: 1, exporter: {:otel_exporter_pid, self()}}} ]) :application.start(:opentelemetry) {:ok, bypass: bypass} end describe "span name" do test "uses generic route name when opentelemetry middleware is configured before path params middleware", %{ bypass: bypass } do defmodule TestClient do def get(client) do params = [id: ~c"3"] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry, Tesla.Middleware.PathParams ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/3", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(name: "/users/:id", attributes: _attributes)} end test "uses low-cardinality method name when path params middleware is not used", %{ bypass: bypass } do defmodule TestClient do def get(client) do Tesla.get(client, "/users/") end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(name: "HTTP GET", attributes: _attributes)} end test "uses custom span name when passed in middleware opts", %{ bypass: bypass } do defmodule TestClient do def get(client) do params = [id: ~c"3"] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, {Tesla.Middleware.OpenTelemetry, span_name: "POST :my-high-cardinality-url"}, Tesla.Middleware.PathParams ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/3", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(name: "POST :my-high-cardinality-url", attributes: _attributes)} end test "uses custom span name function when passed in middleware opts", %{ bypass: bypass } do defmodule TestClient do def get(client) do params = [id: ~c"3"] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, {Tesla.Middleware.OpenTelemetry, span_name: fn env -> "#{String.upcase(to_string(env.method))} potato" end}, Tesla.Middleware.PathParams ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/3", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(name: "GET potato", attributes: _attributes)} end end test "Records spans for Tesla HTTP client", %{bypass: bypass} do defmodule TestClient do def get(client) do Tesla.get(client, "/users/") end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(name: "HTTP GET", attributes: _attributes)} end @error_codes [ 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 500, 501, 502, 503, 504, 505, 506, 507, 508 ] for code <- @error_codes do test "Marks Span status as :error when HTTP request fails with #{code}", %{bypass: bypass} do defmodule TestClient do def get(client) do Tesla.get(client, "/users/") end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users", fn conn -> Plug.Conn.resp(conn, unquote(code), "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(status: {:status, :error, ""})} end end test "Marks Span status as :errors when max redirects are exceeded", %{bypass: bypass} do defmodule TestClient do def get(client) do Tesla.get(client, "/users/") end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry, {Tesla.Middleware.FollowRedirects, max_redirects: 1} ] Tesla.client(middleware) end end Bypass.expect(bypass, "GET", "/users", fn conn -> conn |> Plug.Conn.put_resp_header("Location", "/users/1") |> Plug.Conn.resp(301, "") end) Bypass.expect(bypass, "GET", "/users/1", fn conn -> conn |> Plug.Conn.put_resp_header("Location", "/users/2") |> Plug.Conn.resp(301, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(status: {:status, :error, ""})} end test "Marks Span status as :error if error status is within `mark_status_ok` opt list", %{bypass: bypass} do defmodule TestClient do def get(client) do Tesla.get(client, "/users/") end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, {Tesla.Middleware.OpenTelemetry, mark_status_ok: [404]} ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users", fn conn -> Plug.Conn.resp(conn, 404, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(status: {:status, :ok, ""})} end test "Marks Span status as :ok unless error status is within `mark_status_ok` opt list", %{bypass: bypass} do defmodule TestClient do def get(client) do Tesla.get(client, "/users/") end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, {Tesla.Middleware.OpenTelemetry, mark_status_ok: []} ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users", fn conn -> Plug.Conn.resp(conn, 404, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get() assert_receive {:span, span(status: {:status, :error, ""})} end test "Appends query string parameters to http.url attribute", %{bypass: bypass} do defmodule TestClient do def get(client, id) do params = [id: id] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry, Tesla.Middleware.PathParams, {Tesla.Middleware.Query, [token: "some-token", array: ["foo", "bar"]]} ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/2", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get("2") assert_receive {:span, span(name: _name, attributes: attributes)} mapped_attributes = :otel_attributes.map(attributes) assert mapped_attributes[:"http.url"] == "http://localhost:#{bypass.port}/users/2?token=some-token&array%5B%5D=foo&array%5B%5D=bar" end test "http.url attribute is correct when request doesn't contain query string parameters", %{ bypass: bypass } do defmodule TestClient do def get(client, id) do params = [id: id] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry, Tesla.Middleware.PathParams, {Tesla.Middleware.Query, []} ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/2", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get("2") assert_receive {:span, span(name: _name, attributes: attributes)} mapped_attributes = :otel_attributes.map(attributes) assert mapped_attributes[:"http.url"] == "http://localhost:#{bypass.port}/users/2" end test "Handles url path arguments correctly", %{bypass: bypass} do defmodule TestClient do def get(client, id) do params = [id: id] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry, Tesla.Middleware.PathParams, {Tesla.Middleware.Query, [token: "some-token"]} ] Tesla.client(middleware) end end Bypass.expect_once(bypass, "GET", "/users/2", fn conn -> Plug.Conn.resp(conn, 204, "") end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get("2") assert_receive {:span, span(name: _name, attributes: attributes)} assert %{"http.target": "/users/2"} = :otel_attributes.map(attributes) end test "Records http.response_content_length param into the span", %{bypass: bypass} do defmodule TestClient do def get(client, id) do params = [id: id] Tesla.get(client, "/users/:id", opts: [path_params: params]) end def client(url) do middleware = [ {Tesla.Middleware.BaseUrl, url}, Tesla.Middleware.OpenTelemetry, Tesla.Middleware.PathParams, {Tesla.Middleware.Query, [token: "some-token"]} ] Tesla.client(middleware) end end response = "HELLO 👋" Bypass.expect_once(bypass, "GET", "/users/2", fn conn -> Plug.Conn.resp(conn, 200, response) end) bypass.port |> endpoint_url() |> TestClient.client() |> TestClient.get("2") assert_receive {:span, span(name: _name, attributes: attributes)} mapped_attributes = :otel_attributes.map(attributes) {response_size, _} = Integer.parse(mapped_attributes[:"http.response_content_length"]) assert response_size == byte_size(response) end describe "trace propagation" do test "injects distributed tracing headers by default" do {:ok, env} = Tesla.get(client(), "/propagate-traces") assert traceparent = Tesla.get_header(env, "traceparent") assert is_binary(traceparent) assert_receive {:span, span(name: _name, attributes: attributes)} assert %{"http.target": "/propagate-traces"} = :otel_attributes.map(attributes) end test "optionally disable propagation but keep span report" do {:ok, env} = Tesla.get(client(propagator: :none), "/propagate-traces") refute Tesla.get_header(env, "traceparent") assert_receive {:span, span(name: _name, attributes: attributes)} assert %{"http.target": "/propagate-traces"} = :otel_attributes.map(attributes) end end defp client(opts \\ []) do [ {Tesla.Middleware.OpenTelemetry, opts} ] |> Tesla.client(fn env -> {:ok, env} end) end defp endpoint_url(port), do: "http://localhost:#{port}/" end