Add cowboy_tracer_h stream handler

Another experimental stream handler. It enables tracing for
the connection process and any children processes based on
the matching of the request. It can be used to do ad-hoc
tracing by sending a specific header, path, method or other.

It is meant to be used both for tests and production. Some
configuration scenarios are NOT safe for production, beware.

It's important to understand that, at this time, tracing
is enabled on the scale of the entire connection including
any future request processes. Keep this in mind when trying
to use it in production. The only way to stop tracing is
by having the callback function exit (by calling exit/1
explicitly). This can be done after a certain number of
events for example. Tracing can generate a lot of events,
so it's a good idea to stop after a small number of events
(between 1000 and 10000 should be good) and to avoid tracing
the whole world.

Documentation will follow at a later time.

ebin/cowboy.app

@@ -1,7 +1,7 @@
 {application, 'cowboy', [
 	{description, "Small, fast, modern HTTP server."},
 	{vsn, "2.0.0"},
-	{modules, ['cowboy','cowboy_app','cowboy_bstr','cowboy_children','cowboy_clear','cowboy_clock','cowboy_compress_h','cowboy_constraints','cowboy_handler','cowboy_http','cowboy_http2','cowboy_iolists','cowboy_loop','cowboy_metrics_h','cowboy_middleware','cowboy_req','cowboy_rest','cowboy_router','cowboy_static','cowboy_stream','cowboy_stream_h','cowboy_sub_protocol','cowboy_sup','cowboy_tls','cowboy_websocket']},
+	{modules, ['cowboy','cowboy_app','cowboy_bstr','cowboy_children','cowboy_clear','cowboy_clock','cowboy_compress_h','cowboy_constraints','cowboy_handler','cowboy_http','cowboy_http2','cowboy_iolists','cowboy_loop','cowboy_metrics_h','cowboy_middleware','cowboy_req','cowboy_rest','cowboy_router','cowboy_static','cowboy_stream','cowboy_stream_h','cowboy_sub_protocol','cowboy_sup','cowboy_tls','cowboy_tracer_h','cowboy_websocket']},
 	{registered, [cowboy_sup,cowboy_clock]},
 	{applications, [kernel,stdlib,crypto,cowlib,ranch]},
 	{mod, {cowboy_app, []}},

src/cowboy_tracer_h.erl

@@ -0,0 +1,172 @@
+%% Copyright (c) 2017, Loïc Hoguin <essen@ninenines.eu>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(cowboy_tracer_h).
+-behavior(cowboy_stream).
+
+-export([init/3]).
+-export([data/4]).
+-export([info/3]).
+-export([terminate/3]).
+-export([early_error/5]).
+
+-export([tracer_process/3]).
+-export([system_continue/3]).
+-export([system_terminate/4]).
+-export([system_code_change/4]).
+
+-type match_predicate()
+	:: fun((cowboy_stream:streamid(), cowboy_req:req(), cowboy:opts()) -> boolean()).
+
+-type tracer_match_specs() :: [match_predicate()
+	| {method, binary()}
+	| {host, binary()}
+	| {path, binary()}
+	| {path_start, binary()}
+	| {header, binary()}
+	| {header, binary(), binary()}
+	| {peer_ip, inet:ip_address()}
+].
+-export_type([tracer_match_specs/0]).
+
+-spec init(cowboy_stream:streamid(), cowboy_req:req(), cowboy:opts())
+	-> {cowboy_stream:commands(), any()}.
+init(StreamID, Req, Opts) ->
+	Result = init_tracer(StreamID, Req, Opts),
+	{Commands, Next} = cowboy_stream:init(StreamID, Req, Opts),
+	case Result of
+		no_tracing -> {Commands, Next};
+		{tracing, TracerPid} -> {[{spawn, TracerPid, 5000}|Commands], Next}
+	end.
+
+-spec data(cowboy_stream:streamid(), cowboy_stream:fin(), cowboy_req:resp_body(), State)
+	-> {cowboy_stream:commands(), State} when State::any().
+data(StreamID, IsFin, Data, Next) ->
+	cowboy_stream:data(StreamID, IsFin, Data, Next).
+
+-spec info(cowboy_stream:streamid(), any(), State)
+	-> {cowboy_stream:commands(), State} when State::any().
+info(StreamID, Info, Next) ->
+	cowboy_stream:info(StreamID, Info, Next).
+
+-spec terminate(cowboy_stream:streamid(), cowboy_stream:reason(), any()) -> any().
+terminate(StreamID, Reason, Next) ->
+	cowboy_stream:terminate(StreamID, Reason, Next).
+
+-spec early_error(cowboy_stream:streamid(), cowboy_stream:reason(),
+	cowboy_stream:partial_req(), Resp, cowboy:opts()) -> Resp
+	when Resp::cowboy_stream:resp_command().
+early_error(StreamID, Reason, PartialReq, Resp, Opts) ->
+	cowboy_stream:early_error(StreamID, Reason, PartialReq, Resp, Opts).
+
+%% Internal.
+
+init_tracer(StreamID, Req, Opts=#{tracer_match_specs := List, tracer_callback := _}) ->
+	case match(List, StreamID, Req, Opts) of
+		false ->
+			no_tracing;
+		true ->
+			start_tracer(StreamID, Req, Opts)
+	end;
+%% When the options tracer_match_specs or tracer_callback
+%% arenot provided we do not enable tracing.
+init_tracer(_, _, _) ->
+	no_tracing.
+
+match([], _, _, _) ->
+	true;
+match([Predicate|Tail], StreamID, Req, Opts) when is_function(Predicate) ->
+	case Predicate(StreamID, Req, Opts) of
+		true -> match(Tail, StreamID, Req, Opts);
+		false -> false
+	end;
+match([{method, Value}|Tail], StreamID, Req=#{method := Value}, Opts) ->
+	match(Tail, StreamID, Req, Opts);
+match([{host, Value}|Tail], StreamID, Req=#{host := Value}, Opts) ->
+	match(Tail, StreamID, Req, Opts);
+match([{path, Value}|Tail], StreamID, Req=#{path := Value}, Opts) ->
+	match(Tail, StreamID, Req, Opts);
+match([{path_start, PathStart}|Tail], StreamID, Req=#{path := Path}, Opts) ->
+	Len = byte_size(PathStart),
+	case Path of
+		<<PathStart:Len/binary, _/bits>> -> match(Tail, StreamID, Req, Opts);
+		_ -> false
+	end;
+match([{header, Name}|Tail], StreamID, Req=#{headers := Headers}, Opts) ->
+	case Headers of
+		#{Name := _} -> match(Tail, StreamID, Req, Opts);
+		_ -> false
+	end;
+match([{header, Name, Value}|Tail], StreamID, Req=#{headers := Headers}, Opts) ->
+	case Headers of
+		#{Name := Value} -> match(Tail, StreamID, Req, Opts);
+		_ -> false
+	end;
+match([{peer_ip, IP}|Tail], StreamID, Req=#{peer := {IP, _}}, Opts) ->
+	match(Tail, StreamID, Req, Opts);
+match(_, _, _, _) ->
+	false.
+
+%% We only start the tracer if one wasn't started before.
+start_tracer(StreamID, Req, Opts) ->
+	case erlang:trace_info(self(), tracer) of
+		{tracer, []} ->
+			TracerPid = proc_lib:spawn_link(?MODULE, tracer_process, [StreamID, Req, Opts]),
+			erlang:trace_pattern({'_', '_', '_'}, [{'_', [], [{return_trace}]}], [local]),
+			erlang:trace_pattern(on_load, [{'_', [], [{return_trace}]}], [local]),
+			erlang:trace(self(), true, [
+				send, 'receive', call, return_to, procs, ports,
+				monotonic_timestamp, set_on_spawn, {tracer, TracerPid}
+			]),
+			{tracing, TracerPid};
+		_ ->
+			no_tracing
+	end.
+
+%% Tracer process.
+
+-spec tracer_process(_, _, _) -> no_return().
+tracer_process(StreamID, Req=#{pid := Parent}, Opts=#{tracer_callback := Fun}) ->
+	process_flag(trap_exit, true),
+	State = Fun(init, {StreamID, Req, Opts}),
+	tracer_loop(Parent, Fun, State).
+
+tracer_loop(Parent, Fun, State) ->
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			Fun(Msg, State),
+			tracer_loop(Parent, Fun, State);
+		{'EXIT', Parent, Reason} ->
+			exit(Reason);
+		{system, From, Request} ->
+			sys:handle_system_msg(Request, From, Parent, ?MODULE, [], {Fun, State});
+		Msg ->
+			error_logger:error_msg("~p: Tracer process received stray message ~9999p~n",
+				[?MODULE, Msg]),
+			tracer_loop(Parent, Fun, State)
+	end.
+
+%% System callbacks.
+
+-spec system_continue(pid(), _, {fun(), any()}) -> no_return().
+system_continue(Parent, _, {Fun, State}) ->
+	tracer_loop(Parent, Fun, State).
+
+-spec system_terminate(any(), _, _, _) -> no_return().
+system_terminate(Reason, _, _, _) ->
+	exit(Reason).
+
+-spec system_code_change(Misc, _, _, _) -> {ok, Misc} when Misc::any().
+system_code_change(Misc, _, _, _) ->
+	{ok, Misc}.

test/cowboy_test.erl

@@ -22,19 +22,19 @@
 init_http(Ref, ProtoOpts, Config) ->
 	{ok, _} = cowboy:start_clear(Ref, [{port, 0}], ProtoOpts),
 	Port = ranch:get_port(Ref),
-	[{type, tcp}, {protocol, http}, {port, Port}, {opts, []}|Config].
+	[{ref, Ref}, {type, tcp}, {protocol, http}, {port, Port}, {opts, []}|Config].
 
 init_https(Ref, ProtoOpts, Config) ->
 	Opts = ct_helper:get_certs_from_ets(),
 	{ok, _} = cowboy:start_tls(Ref, Opts ++ [{port, 0}], ProtoOpts),
 	Port = ranch:get_port(Ref),
-	[{type, ssl}, {protocol, http}, {port, Port}, {opts, Opts}|Config].
+	[{ref, Ref}, {type, ssl}, {protocol, http}, {port, Port}, {opts, Opts}|Config].
 
 init_http2(Ref, ProtoOpts, Config) ->
 	Opts = ct_helper:get_certs_from_ets(),
 	{ok, _} = cowboy:start_tls(Ref, Opts ++ [{port, 0}], ProtoOpts),
 	Port = ranch:get_port(Ref),
-	[{type, ssl}, {protocol, http2}, {port, Port}, {opts, Opts}|Config].
+	[{ref, Ref}, {type, ssl}, {protocol, http2}, {port, Port}, {opts, Opts}|Config].
 
 %% Common group of listeners used by most suites.
 

test/tracer_SUITE.erl

@@ -0,0 +1,423 @@
+%% Copyright (c) 2017, Loïc Hoguin <essen@ninenines.eu>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(tracer_SUITE).
+-compile(export_all).
+
+-import(ct_helper, [config/2]).
+-import(ct_helper, [doc/1]).
+-import(cowboy_test, [gun_open/1]).
+-import(cowboy_test, [gun_down/1]).
+
+%% ct.
+
+all() ->
+	cowboy_test:common_all().
+
+%% We want tests for each group to execute sequentially
+%% because we need to modify the protocol options. Groups
+%% can run in parallel however.
+groups() ->
+	Tests = ct_helper:all(?MODULE),
+	[
+		{http, [], Tests},
+		{https, [], Tests},
+		{h2, [], Tests},
+		{h2c, [], Tests},
+		{http_compress, [], Tests},
+		{https_compress, [], Tests},
+		{h2_compress, [], Tests},
+		{h2c_compress, [], Tests}
+	].
+
+init_per_group(Name = http, Config) ->
+	cowboy_test:init_http(Name, init_plain_opts(Config), Config);
+init_per_group(Name = https, Config) ->
+	cowboy_test:init_http(Name, init_plain_opts(Config), Config);
+init_per_group(Name = h2, Config) ->
+	cowboy_test:init_http2(Name, init_plain_opts(Config), Config);
+init_per_group(Name = h2c, Config) ->
+	Config1 = cowboy_test:init_http(Name, init_plain_opts(Config), Config),
+	lists:keyreplace(protocol, 1, Config1, {protocol, http2});
+init_per_group(Name = http_compress, Config) ->
+	cowboy_test:init_http(Name, init_compress_opts(Config), Config);
+init_per_group(Name = https_compress, Config) ->
+	cowboy_test:init_http(Name, init_compress_opts(Config), Config);
+init_per_group(Name = h2_compress, Config) ->
+	cowboy_test:init_http2(Name, init_compress_opts(Config), Config);
+init_per_group(Name = h2c_compress, Config) ->
+	Config1 = cowboy_test:init_http(Name, init_compress_opts(Config), Config),
+	lists:keyreplace(protocol, 1, Config1, {protocol, http2}).
+
+end_per_group(Name, _) ->
+	cowboy:stop_listener(Name).
+
+init_plain_opts(Config) ->
+	#{
+		env => #{dispatch => cowboy_router:compile(init_routes(Config))},
+		stream_handlers => [cowboy_tracer_h, cowboy_stream_h]
+	}.
+
+init_compress_opts(Config) ->
+	#{
+		env => #{dispatch => cowboy_router:compile(init_routes(Config))},
+		stream_handlers => [cowboy_tracer_h, cowboy_compress_h, cowboy_stream_h]
+	}.
+
+init_routes(_) -> [
+	{"localhost", [
+		{"/", hello_h, []},
+		{"/longer/hello/path", hello_h, []}
+	]}
+].
+
+do_get(Path, Config) ->
+	%% Perform a GET request.
+	ConnPid = gun_open(Config),
+	Ref = gun:get(ConnPid, Path, [
+		{<<"accept-encoding">>, <<"gzip">>},
+		{<<"x-test-pid">>, pid_to_list(self())}
+	]),
+	{response, nofin, 200, _Headers} = gun:await(ConnPid, Ref),
+	{ok, _Body} = gun:await_body(ConnPid, Ref),
+	gun:close(ConnPid).
+
+%% We only care about cowboy_req:reply/4 calls.
+do_tracer_callback(Pid) ->
+	fun
+		(init, _) -> undefined;
+		(Event={trace_ts, _, call, {cowboy_req, reply, _}, _}, State) -> Pid ! Event, State;
+		(_, State) -> State
+	end.
+
+%% Tests.
+
+predicate_true(Config) ->
+	doc("Predicate function returns true, unconditionally enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [fun(_,_,_) -> true end]
+	}),
+	do_get("/", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+predicate_false(Config) ->
+	doc("Predicate function returns false, unconditionally disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [fun(_,_,_) -> false end]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+method(Config) ->
+	doc("Method is the same as the request's, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{method, <<"GET">>}]
+	}),
+	do_get("/", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+method_no_match(Config) ->
+	doc("Method is different from the request's, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{method, <<"POST">>}]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+host(Config) ->
+	doc("Host is the same as the request's, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{host, <<"localhost">>}]
+	}),
+	do_get("/", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+host_no_match(Config) ->
+	doc("Host is different from the request's, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{host, <<"ninenines.eu">>}]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+path(Config) ->
+	doc("Path is the same as the request's, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{path, <<"/longer/hello/path">>}]
+	}),
+	do_get("/longer/hello/path", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+path_no_match(Config) ->
+	doc("Path is different from the request's, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{path, <<"/some/other/path">>}]
+	}),
+	do_get("/longer/hello/path", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+path_start(Config) ->
+	doc("Start of path is the same as request's, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{path_start, <<"/longer/hello">>}]
+	}),
+	do_get("/longer/hello/path", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+path_start_no_match(Config) ->
+	doc("Start of path is different from the request's, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{path_start, <<"/shorter/hello">>}]
+	}),
+	do_get("/longer/hello/path", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+header_defined(Config) ->
+	doc("Header is defined in the request, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{header, <<"accept-encoding">>}]
+	}),
+	do_get("/", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+header_defined_no_match(Config) ->
+	doc("Header is not defined in the request, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{header, <<"accept-language">>}]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+header_value(Config) ->
+	doc("Header value is the same as the request's, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{header, <<"accept-encoding">>, <<"gzip">>}]
+	}),
+	do_get("/", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+header_value_no_match(Config) ->
+	doc("Header value is different from the request's, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{header, <<"accept-encoding">>, <<"nope">>}]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+peer_ip(Config) ->
+	doc("Peer IP is the same as the request's, enable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{peer_ip, {127, 0, 0, 1}}]
+	}),
+	do_get("/", Config),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end.
+
+peer_ip_no_match(Config) ->
+	doc("Peer IP is different from the request's, disable tracing."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [{peer_ip, {8, 8, 8, 8}}]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+missing_callback(Config) ->
+	doc("Ensure the request is still processed if the callback is not provided."),
+	Ref = config(ref, Config),
+	Opts0 = ranch:get_protocol_options(Ref),
+	Opts = maps:remove(tracer_callback, Opts0),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_match_specs => [{method, <<"GET">>}]
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+missing_match_specs(Config) ->
+	doc("Ensure the request is still processed if match specs are not provided."),
+	Ref = config(ref, Config),
+	Opts0 = ranch:get_protocol_options(Ref),
+	Opts = maps:remove(tracer_match_specs, Opts0),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self())
+	}),
+	do_get("/", Config),
+	receive
+		Msg when element(1, Msg) =:= trace_ts ->
+			error(Msg)
+	after 100 ->
+		ok
+	end.
+
+two_matching_requests(Config) ->
+	doc("Perform two requests that enable tracing on the same connection."),
+	Ref = config(ref, Config),
+	Opts = ranch:get_protocol_options(Ref),
+	ranch:set_protocol_options(Ref, Opts#{
+		tracer_callback => do_tracer_callback(self()),
+		tracer_match_specs => [fun(_,_,_) -> true end]
+	}),
+	%% Perform a GET request.
+	ConnPid = gun_open(Config),
+	Ref1 = gun:get(ConnPid, "/", []),
+	{response, nofin, 200, _} = gun:await(ConnPid, Ref1),
+	{ok, _} = gun:await_body(ConnPid, Ref1),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end,
+	%% Perform a second GET request on the same connection.
+	Ref2 = gun:get(ConnPid, "/", []),
+	{response, nofin, 200, _} = gun:await(ConnPid, Ref2),
+	{ok, _} = gun:await_body(ConnPid, Ref2),
+	receive
+		{trace_ts, _, call, {cowboy_req, reply, [200, _, _, _]}, _} ->
+			ok
+	after 100 ->
+		error(timeout)
+	end,
+	gun:close(ConnPid).