anchor.diff:      comm:send_local(DHT_Node, {get_node_details, comm:this(), [my_range]}),
       State;
   
  -on({get_node_details_response, NodeDetails} = _Msg, {AllNodes, Leader} = State) ->
  +on({get_node_details_response, NodeDetails} = _Msg,
  +   {AllNodes, Leader, BenchPid, IgnBenchT} = State) ->
       ?TRACE1(_Msg, State),
       case is_leader(node_details:get(NodeDetails, my_range)) of
           false -> State;
  
positive.code:     monitor:proc_set_value(
        ?MODULE, 'read_read', rrd:create(60 * 1000000, 1, {timing_with_hist, ms})).
  
  -spec run_bench() -> ok.
  run_bench() ->
      Key1 = randoms:getRandomString(),
      Key2 = randoms:getRandomString(),
      ReqList = [{read, Key1}, {read, Key2}, {commit}],
      {TimeInUs, _Result} = util:tc(fun api_tx:req_list/1, [ReqList]),
      monitor:proc_set_value(?MODULE, 'read_read',
                             fun(Old) -> rrd:add_now(TimeInUs / 1000, Old) end).
  
  -spec init_system_stats() -> ok.
  init_system_stats() ->
  
negative.code: 
  %% @doc Message handler when the rm_loop module is fully initialized.
  -spec on(message(), state()) -> state().
  on({bench} = Msg, {AllNodes, Leader, BenchPid, _IgnBenchT} = _State) ->
      ?TRACE1(Msg, _State),
      case get_bench_interval() of
          0 -> ok;
          I -> msg_delay:send_local(I, self(), {bench})
      end,
      comm:send_local(BenchPid, Msg),
      % send a timeout so that a haning bench service gets re-started
      msg_delay:send_local(get_bench_timeout_interval(), self(),
                           {bench_timeout, os:timestamp(), BenchPid}),
      {AllNodes, Leader, BenchPid, false};
  
  on({bench_result, Time, TimeInMs} = _Msg,
     {AllNodes, Leader, BenchPid, _IgnBenchT} = _State) ->
      ?TRACE1(_Msg, _State),
      monitor:proc_set_value(?MODULE, 'read_read',
                             fun(Old) -> rrd:add(Time, TimeInMs, Old) end),
      % ignore the bench_timeout message that will follow
      {AllNodes, Leader, BenchPid, true};
  
  on({bench_timeout, Time, BenchPid} = _Msg,
     {AllNodes, Leader, BenchPid, false} = _State) ->
      ?TRACE1(_Msg, _State),
      % the bench service could not reply within get_bench_timeout_interval() seconds
      % -> re-start service (it may hang) and assume this interval as the reported time
      erlang:exit(BenchPid, kill),
      monitor:proc_set_value(
        ?MODULE, 'read_read',
        fun(Old) -> rrd:add(Time, get_bench_timeout_interval() * 1000, Old) end),
      Self = self(),
      NewBenchPid = erlang:spawn(fun() -> bench_service(Self) end),
      {AllNodes, Leader, NewBenchPid, false};
  
  on({bench_timeout, _Time, _BenchPid} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      % old or ignored timeout message
      State;
  
  on({collect_system_stats} = _Msg, State) ->
  