anchor.diff:      gen_server:call(Node, {trace_pid, Pid}).
   
   %% @doc Enables tracing for ets insert/lookup functions calls on the `Node'.
  --spec enable_ets_call_tracing(Node :: atom()) -> ok.
  +-spec enable_ets_call_tracing(Node :: node()) -> ok.
   enable_ets_call_tracing(Node) ->
       gen_server:call(Node, enable_ets_call_tracing).
   
   %% @doc Disables tracing for ets insert/lookup functions calls on the `Node'.
  --spec disable_ets_call_tracing(Node :: atom()) -> ok.
  +-spec disable_ets_call_tracing(Node :: node()) -> ok.
   disable_ets_call_tracing(Node) ->
       gen_server:call(Node, disable_ets_call_tracing).
  +
  +%% @doc Enables tracing for ets insert/lookup functions calls to a particular
  +%% ETS `Table' on the `Node'.
  +-spec enable_ets_table_call_tracing(Node :: node(), Table :: tab()) -> ok.
  +enable_ets_table_call_tracing(Node, Table) ->
  +    gen_server:call(Node, {enable_ets_tab_call_tracing, Table}).
  +
  +%% @doc Disables tracing for ets insert/lookup functions calls to all the ETS
  +%% tables on the `Node'.
  +-spec disable_ets_table_call_tracing(Node :: node()) -> ok.
  +disable_ets_table_call_tracing(Node) ->
  +    disable_ets_call_tracing(Node).
   
   track_timeline(Pid) ->
       Node = erlang:node(Pid),
  
positive.code:          trace_pid/1,
           track_timeline/1,
           enable_ets_call_tracing/1,
           disable_ets_call_tracing/1]).
  
  %% gen_server callbacks
  
negative.code:                          F(F, Ref, Trace);
                       {Ref, Pid, {trace_pid, NewTrace}} when is_pid(NewTrace) ->
                           F(F, Ref, NewTrace);
                       {Ref, _Pid, {enable_ets_call_tracing, TraceFlags,
                                    MatchSpec, Additional}} ->
                           ets:insert(epl_additional, {trace_tab, true}),
                           erlang:trace(all, true, TraceFlags),
                           erlang:trace_pattern({ets, insert, 2}, MatchSpec,
                                                [local]),
                           erlang:trace_pattern({ets, lookup, 2}, MatchSpec,
                                                [local]),
                           F(F, Ref, Trace);
                       {Ref, _Pid, disable_ets_call_tracing} ->
                           erlang:trace_pattern({ets, insert, 2}, false, [local]),
                           erlang:trace_pattern({ets, lookup, 2}, false, [local]),
                           erlang:trace(all, false, [call, return_to]),
                           ets:insert(epl_additional, {trace_tab, false}),
                           F(F, Ref, Trace);
                       {Ref, Pid, List} when is_list(List) ->
                           %% received list of commands to execute
  