anchor.diff:          %% {Micro, Result} = better_timer(Handler, handle_function, [Function, Params]),
           %% error_logger:info_msg("Processed ~p(~p) in ~.4fms~n",
           %%                       [Function, Params, Micro/1000.0]),
  -        handle_success(State1, Function, Result)
  +        handle_success(State1, Function, Result, Seqid)
       catch
           Type:Data when Type =:= throw orelse Type =:= error ->
  -            handle_function_catch(State1, Function, Type, Data)
  +            handle_function_catch(State1, Function, Type, Data, Seqid)
       end.
   
   handle_function_catch(State = #thrift_processor{service = Service},
  -                      Function, ErrType, ErrData) ->
  +                      Function, ErrType, ErrData, Seqid) ->
       IsOneway = Service:function_info(Function, reply_type) =:= oneway_void,
   
       case {ErrType, ErrData} of
  
positive.code: handle_function(State0=#thrift_processor{protocol = Proto0,
                                           handler = Handler,
                                           service = Service},
                  Function) ->
      InParams = Service:function_info(Function, params_type),
  
      {Proto1, {ok, Params}} = thrift_protocol:read(Proto0, InParams),
  
negative.code:     State1 = State0#thrift_processor{protocol = Proto1},
      case MessageBegin of
          #protocol_message_begin{name = Function,
                                  type = ?tMessageType_CALL,
                                  seqid = Seqid} ->
              {State2, ok} = handle_function(State1, list_to_atom(Function), Seqid),
              loop(State2);
          #protocol_message_begin{name = Function,
                                  type = ?tMessageType_ONEWAY, 
                                  seqid = Seqid} ->
              {State2, ok} = handle_function(State1, list_to_atom(Function), Seqid),
              loop(State2);
          {error, timeout} ->
              thrift_protocol:close_transport(Proto1),
  