aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLoïc Hoguin <[email protected]>2017-10-27 13:00:00 +0100
committerLoïc Hoguin <[email protected]>2017-10-27 17:18:28 +0100
commitf4331f7c169309c9017b9628fe3757fc5312270b (patch)
tree1a6de548596c7363492cf75c939321e7ffde96df
parentef58e15547ee171a716eaa768374e2e7e2f7d397 (diff)
downloadcowboy-f4331f7c169309c9017b9628fe3757fc5312270b.tar.gz
cowboy-f4331f7c169309c9017b9628fe3757fc5312270b.tar.bz2
cowboy-f4331f7c169309c9017b9628fe3757fc5312270b.zip
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.
-rw-r--r--ebin/cowboy.app2
-rw-r--r--src/cowboy_tracer_h.erl172
-rw-r--r--test/cowboy_test.erl6
-rw-r--r--test/tracer_SUITE.erl423
4 files changed, 599 insertions, 4 deletions
diff --git a/ebin/cowboy.app b/ebin/cowboy.app
index 356628d..8efc8af 100644
--- a/ebin/cowboy.app
+++ b/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, []}},
diff --git a/src/cowboy_tracer_h.erl b/src/cowboy_tracer_h.erl
new file mode 100644
index 0000000..1f054e3
--- /dev/null
+++ b/src/cowboy_tracer_h.erl
@@ -0,0 +1,172 @@
+%% Copyright (c) 2017, Loïc Hoguin <[email protected]>
+%%
+%% 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}.
diff --git a/test/cowboy_test.erl b/test/cowboy_test.erl
index 31cba63..bdeb801 100644
--- a/test/cowboy_test.erl
+++ b/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.
diff --git a/test/tracer_SUITE.erl b/test/tracer_SUITE.erl
new file mode 100644
index 0000000..40ede6c
--- /dev/null
+++ b/test/tracer_SUITE.erl
@@ -0,0 +1,423 @@
+%% Copyright (c) 2017, Loïc Hoguin <[email protected]>
+%%
+%% 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).