Merge pull request #2352 from rabbitmq/honeycomb

Add honeycomb integration for tests

1 files changed, 105 insertions, 0 deletions

diff --git a/test/honeycomb_cth.erl b/test/honeycomb_cth.erl
new file mode 100644
index 0000000000..dd82da13c7
--- /dev/null
+++ b/test/honeycomb_cth.erl
@@ -0,0 +1,105 @@
+-module(honeycomb_cth).
+
+-export([id/1]).
+-export([init/2]).
+
+-export([pre_init_per_testcase/4]).
+-export([post_end_per_testcase/5]).
+
+-record(state, {directory, github_workflow, github_run_id,
+                github_repository, github_sha, github_ref,
+                base_rmq_ref, secondary_umbrella,
+                erlang_version, elixir_version,
+                otp_release, cpu_topology, schedulers,
+                system_architecture, system_memory_data,
+                start_times = #{}}).
+
+id(Opts) ->
+    proplists:get_value(directory, Opts, "/tmp/honeycomb").
+
+init(Id, _Opts) ->
+    application:ensure_all_started(os_mon),
+    {ok, #state{directory = Id,
+                github_workflow = os:getenv("GITHUB_WORKFLOW", "unknown"),
+                github_run_id = os:getenv("GITHUB_RUN_ID", "unknown"),
+                github_repository = os:getenv("GITHUB_REPOSITORY", "unknown"),
+                github_sha = os:getenv("GITHUB_SHA", "unknown"),
+                github_ref = os:getenv("GITHUB_REF", "unknown"),
+                base_rmq_ref = os:getenv("BASE_RMQ_REF", "unknown"),
+                secondary_umbrella = os:getenv("SECONDARY_UMBRELLA", "none"),
+                erlang_version = os:getenv("ERLANG_VERSION", "unknown"),
+                elixir_version = os:getenv("ELIXIR_VERSION", "unknown"),
+                otp_release = erlang:system_info(otp_release),
+                cpu_topology = erlang:system_info(cpu_topology),
+                schedulers = erlang:system_info(schedulers),
+                system_architecture = erlang:system_info(system_architecture),
+                system_memory_data = memsup:get_system_memory_data()}}.
+
+pre_init_per_testcase(Suite, TC, Config, #state{start_times = StartTimes} = State) ->
+    SuiteTimes = maps:get(Suite, StartTimes, #{}),
+    {Config, State#state{start_times =
+                             StartTimes#{Suite =>
+                                             SuiteTimes#{TC => erlang:timestamp()}}}}.
+
+post_end_per_testcase(Suite, TC, _Config, Return, #state{github_workflow = GithubWorkflow,
+                                                         github_run_id = GithubRunId,
+                                                         github_repository = GithubRepository,
+                                                         github_sha = GithubSha,
+                                                         github_ref = GithubRef,
+                                                         base_rmq_ref = BaseRmqRef,
+                                                         secondary_umbrella = SecondaryUmbrella,
+                                                         erlang_version = ErlangVersion,
+                                                         elixir_version = ElixirVersion,
+                                                         otp_release = OtpRelease,
+                                                         cpu_topology = CpuTopology,
+                                                         schedulers = Schedulers,
+                                                         system_architecture = SystemArchitecture,
+                                                         system_memory_data = SystemMemoryData,
+                                                         start_times = StartTimes} = State) ->
+    EndTime = erlang:timestamp(),
+    SuiteTimes = maps:get(Suite, StartTimes),
+    {StartTime, SuiteTimes1} = maps:take(TC, SuiteTimes),
+    DurationMicroseconds = timer:now_diff(EndTime, StartTime),
+
+    File = filename(Suite, TC, State),
+    ok = filelib:ensure_dir(File),
+    {ok, F} = file:open(File, [write]),
+
+    Json = jsx:encode([{<<"ci">>, <<"GitHub Actions">>},
+                       {<<"github_workflow">>, list_to_binary(GithubWorkflow)},
+                       {<<"github_run_id">>, list_to_binary(GithubRunId)},
+                       {<<"github_repository">>, list_to_binary(GithubRepository)},
+                       {<<"github_sha">>, list_to_binary(GithubSha)},
+                       {<<"github_ref">>, list_to_binary(GithubRef)},
+                       {<<"base_rmq_ref">>, list_to_binary(BaseRmqRef)},
+                       {<<"secondary_umbrella">>, list_to_binary(SecondaryUmbrella)},
+                       {<<"erlang_version">>, list_to_binary(ErlangVersion)},
+                       {<<"elixir_version">>, list_to_binary(ElixirVersion)},
+                       {<<"otp_release">>, list_to_binary(OtpRelease)},
+                       {<<"cpu_topology">>, cpu_topology_json_term(CpuTopology)},
+                       {<<"schedulers">>, Schedulers},
+                       {<<"system_architecture">>, list_to_binary(SystemArchitecture)},
+                       {<<"system_memory_data">>, memory_json_term(SystemMemoryData)},
+                       {<<"suite">>, list_to_binary(atom_to_list(Suite))},
+                       {<<"testcase">>, list_to_binary(atom_to_list(TC))},
+                       {<<"duration_seconds">>, DurationMicroseconds / 1000000},
+                       {<<"result">>, list_to_binary(io_lib:format("~p", [Return]))}]),
+
+    file:write(F, Json),
+    file:close(F),
+    {Return, State#state{start_times = StartTimes#{Suite := SuiteTimes1}}}.
+
+filename(Suite, TC, #state{directory = Dir}) ->
+    filename:join(Dir,
+                  integer_to_list(erlang:system_time())
+                  ++ "_" ++ atom_to_list(Suite)
+                  ++ "_" ++ atom_to_list(TC)
+                  ++ ".json").
+
+memory_json_term(SystemMemoryData) when is_list(SystemMemoryData) ->
+    [{list_to_binary(atom_to_list(K)), V} || {K, V} <- SystemMemoryData].
+
+cpu_topology_json_term([{processor, Cores}]) when is_list(Cores) ->
+    [{<<"processor">>, [begin
+                            [{<<"core">>, [{list_to_binary(atom_to_list(Kind)), Index}]}]
+                        end || {core, {Kind, Index}} <- Cores]}].