anchor.diff:  
   -spec report_slow_handler(trace_id(), state_t()) -> ok.
   report_slow_handler(Tid, Entry) ->
  -    {delivered, GPid, _Ref, StartTime, _OldSendOptions} = Entry#state.status,
  +    {delivered, GPid, _Ref, StartTime} = Entry#state.status,
       Delta = (timer:now_diff(os:timestamp(), StartTime) div 100000)/10,
       {PidGrpName, StackTrace} =
           case comm:is_local(GPid) of
  
positive.code:              end
       end;
  
  on({send_error, Pid, Msg, Reason} = _ShepherdMsg, State) ->
      %% call on_handler_done and continue with message delivery
      TraceId = get_trace_id(get_passed_state(Msg)),
      ?TRACE("send error for trace id ~p: ~p calling on_handler_done.", [TraceId, _ShepherdMsg]),
      case lists:keyfind(TraceId, 1, State) of
          false -> State;
          {TraceId, TraceEntry} ->
              case TraceEntry#state.status of
                  {delivered, Pid, _Ref, _Time, OldSendOptions} ->
                      %% send error, generate on_handler_done and enqueue a
                      %% send_error message if a shepherd was used
                      State1 =
                          case lists:keyfind(shepherd, 1, OldSendOptions) of
                              {shepherd, ShepherdPid} ->
                                  % work with envelopes
                                  {RealShepherdPid, RealMsg} =
                                      comm:unpack_cookie(
                                        ShepherdPid,
                                        {send_error, Pid, get_orig_msg(Msg), Reason}),
                                  TmpEntry =
                                      add_message(whereis(comm_server),
                                                  RealShepherdPid, RealMsg,
                                                  local, [], TraceEntry),
                                  lists:keystore(TraceId, 1, State, {TraceId, TmpEntry});
                              false ->
                                  State
                          end,
                      gen_component:post_op({on_handler_done, TraceId, send_error, Pid}, State1);
                  _  ->
                      %% not in state delivered, so probably the monitor
                      %% already cleaned up for the died process with
                      %% its 'DOWN' message.
                      State
              end
      end;
  
  
negative.code:         new ->
              %% still waiting for all threads to join
              lists:keystore(TraceId, 1, State, {TraceId, NewEntry});
          {delivered, FromGPid, _Ref, _DeliverTime} ->
              %% only From is allowed to enqueue infos
              %% only when delivered or to_be_cleaned (during execution
              %% of a scheduled piece of code) new arbitrary infos
  