opentelemetry-erlang-contrib/instrumentation/opentelemetry_phoenix/test/opentelemetry_phoenix_test.exs

456 lines
13 KiB
Elixir

defmodule OpentelemetryPhoenixTest do
use ExUnit.Case, async: false
doctest OpentelemetryPhoenix
require OpenTelemetry.Tracer
require OpenTelemetry.Span
require Record
alias PhoenixMeta, as: Meta
alias PhoenixLiveViewMeta, as: LiveViewMeta
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
:otel_simple_processor.set_exporter(:otel_exporter_pid, self())
:ok
end
test "records spans for Phoenix web requests" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :endpoint, :start],
%{system_time: System.system_time()},
Meta.endpoint_start()
)
:telemetry.execute(
[:phoenix, :router_dispatch, :start],
%{system_time: System.system_time()},
Meta.router_dispatch_start()
)
:telemetry.execute(
[:phoenix, :endpoint, :stop],
%{duration: 444},
Meta.endpoint_stop()
)
assert_receive {:span,
span(
name: "/users/:user_id",
attributes: attributes,
parent_span_id: 13_235_353_014_750_950_193
)}
assert %{
"http.client_ip": "10.211.55.2",
"http.flavor": :"1.1",
"net.host.name": "localhost",
"http.method": "GET",
"http.route": "/users/:user_id",
"http.scheme": "http",
"http.status_code": 200,
"http.target": "/users/123",
"http.user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:81.0) Gecko/20100101 Firefox/81.0",
"net.sock.host.addr": "10.211.55.2",
"net.host.port": 4000,
"net.sock.peer.addr": "10.211.55.2",
"net.peer.port": 64291,
"net.transport": :"IP.TCP",
"phoenix.action": :user,
"phoenix.plug": Elixir.MyStoreWeb.PageController
} == :otel_attributes.map(attributes)
end
test "parses x-forwarded-for with single value" do
OpentelemetryPhoenix.setup()
x_forwarded_for_request("203.0.113.195")
assert_receive {:span, span(attributes: attributes)}
assert Map.fetch!(:otel_attributes.map(attributes), :"http.client_ip") == "203.0.113.195"
end
test "parses x-forwarded-for with multiple values" do
OpentelemetryPhoenix.setup()
x_forwarded_for_request("203.0.113.195, 70.41.3.18, 150.172.238.178")
assert_receive {:span, span(attributes: attributes)}
assert Map.fetch!(:otel_attributes.map(attributes), :"http.client_ip") == "203.0.113.195"
end
test "records exceptions for Phoenix web requests" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :endpoint, :start],
%{system_time: System.system_time()},
Meta.endpoint_start(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :start],
%{system_time: System.system_time()},
Meta.router_dispatch_start(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :exception],
%{duration: 222},
Meta.router_dispatch_exception(:normal)
)
:telemetry.execute(
[:phoenix, :endpoint, :stop],
%{duration: 444},
Meta.endpoint_stop(:exception)
)
expected_status = OpenTelemetry.status(:error, "")
assert_receive {:span,
span(
name: "/users/:user_id/exception",
attributes: attributes,
kind: :server,
events: events,
parent_span_id: 13_235_353_014_750_950_193,
status: ^expected_status
)}
assert %{
"http.client_ip": "10.211.55.2",
"http.flavor": :"1.1",
"net.host.name": "localhost",
"http.method": "GET",
"http.route": "/users/:user_id/exception",
"http.scheme": "http",
"http.status_code": 500,
"http.target": "/users/123/exception",
"http.user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:81.0) Gecko/20100101 Firefox/81.0",
"net.sock.host.addr": "10.211.55.2",
"net.host.port": 4000,
"net.sock.peer.addr": "10.211.55.2",
"net.peer.port": 64291,
"net.transport": :"IP.TCP",
"phoenix.action": :code_exception,
"phoenix.plug": MyStoreWeb.PageController
} == :otel_attributes.map(attributes)
[
event(
name: "exception",
attributes: event_attributes
)
] = :otel_events.list(events)
assert [:"exception.message", :"exception.stacktrace", :"exception.type", :key, :map] ==
Enum.sort(Map.keys(:otel_attributes.map(event_attributes)))
end
test "records exceptions for nested Phoenix routers" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :endpoint, :start],
%{system_time: System.system_time()},
Meta.endpoint_start(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :start],
%{system_time: System.system_time()},
Meta.router_dispatch_start(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :exception],
%{duration: 222},
Meta.router_dispatch_exception(:normal)
)
:telemetry.execute(
[:phoenix, :endpoint, :stop],
%{duration: 444},
Meta.endpoint_stop(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :exception],
%{duration: 222},
Meta.router_dispatch_exception(:normal)
)
assert_receive {:span, _}
assert [_ | _] = :telemetry.list_handlers([:phoenix, :router_dispatch, :exception])
end
test "records exceptions for Phoenix web requests with plug wrappers" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :endpoint, :start],
%{system_time: System.system_time()},
Meta.endpoint_start(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :start],
%{system_time: System.system_time()},
Meta.router_dispatch_start(:exception)
)
:telemetry.execute(
[:phoenix, :router_dispatch, :exception],
%{duration: 222},
Meta.router_dispatch_exception(:plug_wrapper)
)
:telemetry.execute(
[:phoenix, :endpoint, :stop],
%{duration: 444},
Meta.endpoint_stop(:exception)
)
expected_status = OpenTelemetry.status(:error, "")
assert_receive {:span,
span(
name: "/users/:user_id/exception",
attributes: attributes,
kind: :server,
events: events,
parent_span_id: 13_235_353_014_750_950_193,
status: ^expected_status
)}
assert %{
"http.client_ip": "10.211.55.2",
"http.flavor": :"1.1",
"net.host.name": "localhost",
"http.method": "GET",
"http.route": "/users/:user_id/exception",
"http.scheme": "http",
"http.status_code": 500,
"http.target": "/users/123/exception",
"http.user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:81.0) Gecko/20100101 Firefox/81.0",
"net.sock.host.addr": "10.211.55.2",
"net.host.port": 4000,
"net.sock.peer.addr": "10.211.55.2",
"net.peer.port": 64291,
"net.transport": :"IP.TCP",
"phoenix.action": :code_exception,
"phoenix.plug": MyStoreWeb.PageController
} == :otel_attributes.map(attributes)
[
event(
name: "exception",
attributes: event_attributes
)
] = :otel_events.list(events)
assert [:"exception.message", :"exception.stacktrace", :"exception.type"] ==
Enum.sort(Map.keys(:otel_attributes.map(event_attributes)))
end
test "records spans for Phoenix LiveView mount" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :live_view, :mount, :start],
%{system_time: System.system_time()},
LiveViewMeta.mount_start()
)
:telemetry.execute(
[:phoenix, :live_view, :mount, :stop],
%{system_time: System.system_time()},
LiveViewMeta.mount_stop()
)
assert_receive {:span,
span(
name: "NnnnnWeb.MyTestLive.mount",
attributes: attributes
)}
assert %{} == :otel_attributes.map(attributes)
end
test "records spans for Phoenix LiveView handle_params" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :live_view, :handle_params, :start],
%{system_time: System.system_time()},
LiveViewMeta.handle_params_start()
)
:telemetry.execute(
[:phoenix, :live_view, :handle_params, :stop],
%{system_time: System.system_time()},
LiveViewMeta.handle_params_stop()
)
assert_receive {:span,
span(
name: "NnnnnWeb.MyTestLive.handle_params",
attributes: attributes
)}
assert %{} == :otel_attributes.map(attributes)
end
test "records spans for Phoenix LiveView handle_event" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :live_view, :handle_event, :start],
%{system_time: System.system_time()},
LiveViewMeta.handle_event_start()
)
:telemetry.execute(
[:phoenix, :live_view, :handle_event, :stop],
%{system_time: System.system_time()},
LiveViewMeta.handle_event_stop()
)
assert_receive {:span,
span(
name: "NnnnnWeb.MyTestLive.handle_event#hello",
attributes: attributes
)}
assert %{} == :otel_attributes.map(attributes)
end
test "handles exception during Phoenix LiveView handle_params" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :live_view, :mount, :start],
%{system_time: System.system_time()},
LiveViewMeta.mount_start(:exception)
)
:telemetry.execute(
[:phoenix, :live_view, :mount, :stop],
%{system_time: System.system_time()},
LiveViewMeta.mount_stop(:exception)
)
:telemetry.execute(
[:phoenix, :live_view, :handle_params, :start],
%{system_time: System.system_time()},
LiveViewMeta.handle_params_start(:exception)
)
:telemetry.execute(
[:phoenix, :live_view, :handle_params, :exception],
%{system_time: System.system_time()},
LiveViewMeta.handle_params_exception(:exception)
)
assert_receive {:span,
span(
name: "NnnnnWeb.MyTestLive.mount",
attributes: attributes
)}
assert %{} == :otel_attributes.map(attributes)
assert_receive {:span,
span(
name: "NnnnnWeb.MyTestLive.handle_params",
attributes: attributes,
events: events
)}
assert %{} == :otel_attributes.map(attributes)
[
event(
name: "exception",
attributes: event_attributes
)
] = :otel_events.list(events)
assert [:"exception.message", :"exception.stacktrace", :"exception.type"] ==
Enum.sort(Map.keys(:otel_attributes.map(event_attributes)))
end
test "handles exceptions during Phoenix LiveView handle_event" do
OpentelemetryPhoenix.setup()
:telemetry.execute(
[:phoenix, :live_view, :handle_event, :start],
%{system_time: System.system_time()},
LiveViewMeta.handle_event_start(:exception)
)
:telemetry.execute(
[:phoenix, :live_view, :handle_event, :exception],
%{system_time: System.system_time()},
LiveViewMeta.handle_event_exception(:exception)
)
assert_receive {:span,
span(
name: "NnnnnWeb.MyTestLive.handle_event#hello",
attributes: attributes,
events: events
)}
assert %{} == :otel_attributes.map(attributes)
[
event(
name: "exception",
attributes: event_attributes
)
] = :otel_events.list(events)
assert [:"exception.message", :"exception.stacktrace", :"exception.type"] ==
Enum.sort(Map.keys(:otel_attributes.map(event_attributes)))
end
defp x_forwarded_for_request(x_forwarded_for) do
meta = Meta.endpoint_start()
meta = %{
meta
| conn: %{
meta.conn
| req_headers: [{"x-forwarded-for", x_forwarded_for} | meta.conn.req_headers]
}
}
:telemetry.execute(
[:phoenix, :endpoint, :start],
%{system_time: System.system_time()},
meta
)
:telemetry.execute(
[:phoenix, :endpoint, :stop],
%{duration: 444},
Meta.endpoint_stop()
)
end
end