ft: 目录调整

src/lg.erl → src/eTpf.erl

@@ -12,7 +12,7 @@
 %% If you have any questions regarding licensing, please contact us at
 %% info@rabbitmq.com.
 
--module(lg).
+-module(eTpf).
 
 -export([trace/1]).
 -export([trace/2]).

src/lg_callgrind.erl → src/profile/lg_callgrind.erl

@@ -80,7 +80,7 @@
     sources = #{} :: #{mfa() => {string(), pos_integer()}}
 }).
 
--spec patterns() -> lg:input().
+-spec patterns() -> eTpf:input().
 patterns() ->
     [{app, kernel}, {app, stdlib}, {app, looking_glass}].
 

test/lg_SUITE.erl

@@ -18,17 +18,17 @@ groups() ->
 
 app(Config) ->
     doc("Trace a specific application."),
-    lg:trace({app, stdlib}, lg_file_tracer, config(priv_dir, Config) ++ "/app.lz4"),
+    eTpf:trace({app, stdlib}, lg_file_tracer, config(priv_dir, Config) ++ "/app.lz4"),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/app.lz4").
 
 callback(Config) ->
     doc("Trace using patterns from a callback function."),
-    lg:trace({callback, ?MODULE, do_callback}, lg_file_tracer,
+    eTpf:trace({callback, ?MODULE, do_callback}, lg_file_tracer,
         config(priv_dir, Config) ++ "/callback.lz4"),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/callback.lz4").
 
 do_callback() ->
@@ -37,11 +37,11 @@ do_callback() ->
 callgrind_running(Config) ->
     doc("Save events to files on disk then build callgrind files."),
     PrivDir = config(priv_dir, Config),
-    lg:trace([{scope, [self()]}, ?MODULE, {app, stdlib}], lg_file_tracer,
+    eTpf:trace([{scope, [self()]}, ?MODULE, {app, stdlib}], lg_file_tracer,
         PrivDir ++ "/callgrind_running.lz4",
         #{mode => profile, running => true}),
     do_callgrind_running(),
-    lg:stop(),
+    eTpf:stop(),
     lg_callgrind:profile_many(
         PrivDir ++ "/callgrind_running.lz4.*",
         PrivDir ++ "/callgrind_running.out",
@@ -75,11 +75,11 @@ callgrind_running_cycle(Config) ->
     doc("Save events to files on disk then build callgrind files. "
         "Create a recursive cycle using two functions calling each other."),
     PrivDir = config(priv_dir, Config),
-    lg:trace([{scope, [self()]}, ?MODULE, {app, stdlib}], lg_file_tracer,
+    eTpf:trace([{scope, [self()]}, ?MODULE, {app, stdlib}], lg_file_tracer,
         PrivDir ++ "/callgrind_running_cycle.lz4",
         #{mode => profile, running => true}),
     do_callgrind_running_cycle(),
-    lg:stop(),
+    eTpf:stop(),
     lg_callgrind:profile_many(
         PrivDir ++ "/callgrind_running_cycle.lz4.*",
         PrivDir ++ "/callgrind_running_cycle.out",
@@ -126,21 +126,21 @@ do_callgrind_running_cycle2(Ref) ->
 
 file_tracer(Config) ->
     doc("Save events to files on disk."),
-    lg:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/file_tracer.lz4"),
+    eTpf:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/file_tracer.lz4"),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/file_tracer.lz4").
 
 file_tracer_rotation(Config) ->
     doc("Save events to files on disk; rotate the files if they get too big."),
     Prefix = config(priv_dir, Config) ++ "/file_tracer.lz4",
-    lg:trace(lists, lg_file_tracer, #{
+    eTpf:trace(lists, lg_file_tracer, #{
         filename_prefix => Prefix,
         max_size => 100, %% Intentionally low.
         events_per_frame => 10 %% Needed to trigger the rotation, default is too high.
     }),
     lists:seq(1,1000),
-    lg:stop(),
+    eTpf:stop(),
     %% We should have one or more rotated files.
     Result = [begin
         Filename = Prefix ++ "." ++ integer_to_list(N) ++ ".bak",
@@ -151,39 +151,39 @@ file_tracer_rotation(Config) ->
 
 mod(Config) ->
     doc("Trace a specific module."),
-    lg:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/mod.lz4"),
+    eTpf:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/mod.lz4"),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/mod.lz4").
 
 profile_mode(Config) ->
     doc("Trace a specific module in profile mode."),
-    lg:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/profile_mode.lz4",
+    eTpf:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/profile_mode.lz4",
         #{mode => profile}),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/profile_mode.lz4").
 
 raw_console_tracer(_) ->
     doc("Print raw events to the console."),
     ct:print("Start tracing to the console."),
     %% @todo It seems the order matters when starting. Should it?
-    lg:trace([{scope, [self()]}, lists]),
+    eTpf:trace([{scope, [self()]}, lists]),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     ct:print("Stop tracing to the console.").
 
 running_true(Config) ->
     doc("Trace a specific module with running option enabled."),
-    lg:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/running_true.lz4",
+    eTpf:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/running_true.lz4",
         #{running => true}),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/running_true.lz4").
 
 send_true(Config) ->
     doc("Trace a specific module with send option enabled."),
-    lg:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/send_true.lz4",
+    eTpf:trace(lists, lg_file_tracer, config(priv_dir, Config) ++ "/send_true.lz4",
         #{send => true}),
     Self = self(),
     %% Send a message to and from an existing process.
@@ -198,28 +198,28 @@ send_true(Config) ->
     DeadPid = spawn(fun() -> ok end),
     receive after 100 -> ok end,
     DeadPid ! {msg_from, Self},
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/send_true.lz4").
 
 socket_tracer(_) ->
     doc("Send events to a socket."),
     Port = 61234,
-    lg:trace(lists, lg_socket_tracer, Port, #{pool_size => 1}),
+    eTpf:trace(lists, lg_socket_tracer, Port, #{pool_size => 1}),
     {ok, Socket} = gen_tcp:connect("localhost", Port,
         [binary, {packet, 2}, {active, true}]),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_socket_tracer_recv(Socket).
 
 socket_tracer_client(Config) ->
     doc("Send events to a socket client."),
     Port = 61234,
-    lg:trace(lists, lg_socket_tracer, Port, #{pool_size => 1}),
+    eTpf:trace(lists, lg_socket_tracer, Port, #{pool_size => 1}),
     BaseFilename = config(priv_dir, Config) ++ "/socket_tracer_client.lz4",
     {ok, Pid} = lg_socket_client:start_link(Port, BaseFilename),
     timer:sleep(1000),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     lg_socket_client:stop(Pid),
     {ok, File} = file:read_file(BaseFilename ++ ".0"),
     _ = lz4f:decompress(File),
@@ -229,26 +229,26 @@ socket_tracer_client(Config) ->
 socket_tracer_many(_) ->
     doc("Send events to many sockets."),
     Port = 61234,
-    lg:trace(lists, lg_socket_tracer, Port, #{pool_size => 5}),
+    eTpf:trace(lists, lg_socket_tracer, Port, #{pool_size => 5}),
     {ok, _} = gen_tcp:connect("localhost", Port, []),
     {ok, _} = gen_tcp:connect("localhost", Port + 1, []),
     {ok, _} = gen_tcp:connect("localhost", Port + 2, []),
     {ok, _} = gen_tcp:connect("localhost", Port + 3, []),
     {ok, _} = gen_tcp:connect("localhost", Port + 4, []),
     {error, _} = gen_tcp:connect("localhost", Port + 5, []),
-    lg:stop().
+    eTpf:stop().
 
 socket_tracer_reconnect(_) ->
     doc("Confirm we can reconnect to the tracer."),
     Port = 61234,
-    lg:trace(lists, lg_socket_tracer, Port, #{pool_size => 1}),
+    eTpf:trace(lists, lg_socket_tracer, Port, #{pool_size => 1}),
     {ok, Socket0} = gen_tcp:connect("localhost", Port,
         [binary, {packet, 2}, {active, true}]),
     ok = gen_tcp:close(Socket0),
     {ok, Socket} = gen_tcp:connect("localhost", Port,
         [binary, {packet, 2}, {active, true}]),
     lists:seq(1,10),
-    lg:stop(),
+    eTpf:stop(),
     do_socket_tracer_recv(Socket).
 
 do_socket_tracer_recv(Socket) ->
@@ -267,10 +267,10 @@ stop_while_trace_is_running(Config) ->
     doc("Stop tracing while events are still coming in."),
     Self = self(),
     Pid = spawn_link(fun() -> Self ! {self(), continue}, lists:seq(1,10000000) end),
-    lg:trace([{scope, [Pid]}, lists], lg_file_tracer,
+    eTpf:trace([{scope, [Pid]}, lists], lg_file_tracer,
         config(priv_dir, Config) ++ "/stop_while_trace_is_running.lz4"),
     receive {Pid, continue} -> ok after 100 -> error(timeout) end,
-    lg:stop(),
+    eTpf:stop(),
     do_ensure_decompress(config(priv_dir, Config) ++ "/stop_while_trace_is_running.lz4").
 
 %% Internal.