anchor.diff:  schedule_timeout(Timeout) ->
       erlang:send_after(Timeout, self(), request_timeout).
   
  -client_reply(Reply, #state{from = {raw, ReqId, Pid}}) ->
  -    Pid ! {ReqId, Reply}.
  +client_reply(Reply, State = #state{from = {raw, ReqId, Pid}, options = Options}) ->
  +    State2 = add_timing(reply, State),
  +    Reply2 = case proplists:get_value(details, Options, false) of
  +                 false ->
  +                     Reply;
  +                 [] ->
  +                     Reply;
  +                 Details ->
  +                     add_client_info(Reply, Details, State2)
  +             end,
  +    Pid ! {ReqId, Reply2},
  +    add_timing(reply, State2#state{reply = Reply}).
  +
  +add_client_info(Reply, Details, State) ->
  +    Info = client_info(Details, State, []),
  +    case Reply of
  +        ok ->
  +            {ok, Info};
  +        {OkError, ObjReason} ->
  +            {OkError, ObjReason, Info}
  +    end.
  +
  +client_info(true, StateData, Info) ->
  +    client_info(default_details(), StateData, Info);
  +client_info([], _StateData, Info) ->
  +    Info;
  +client_info([timing | Rest], StateData = #state{timing = Timing}, Info) ->
  +    %% Duration is time from receiving request to responding
  +    {ResponseUsecs, Stages} = calc_timing(Timing),
  +    client_info(Rest, StateData, [{response_usecs, ResponseUsecs},
  +                                  {stages, Stages} | Info]).
  +
  +default_details() ->
  +    [timing].
  +
  +
  +%% Add timing information to the state
  +add_timing(Stage, State = #state{timing = Timing}) ->
  +    State#state{timing = [{Stage, os:timestamp()} | Timing]}.
  +
  +%% Calc timing information - stored as {Stage, StageStart} in reverse order. 
  +%% ResponseUsecs is calculated as time from reply to start.
  +calc_timing([{Stage, Now} | Timing]) ->
  +    ReplyNow = case Stage of
  +                   reply ->
  +                       Now;
  +                   _ ->
  +                       undefined
  +               end,
  +    calc_timing(Timing, Now, ReplyNow, []).
  +
  +%% Each timing stage has start time.
  +calc_timing([], StageEnd, ReplyNow, Stages) ->
  +    %% StageEnd is prepare time
  +    {timer:now_diff(ReplyNow, StageEnd), Stages}; 
  +calc_timing([{reply, ReplyNow}|_]=Timing, StageEnd, undefined, Stages) ->
  +    %% Populate ReplyNow then handle normally.
  +    calc_timing(Timing, StageEnd, ReplyNow, Stages);
  +calc_timing([{Stage, StageStart} | Rest], StageEnd, ReplyNow, Stages) ->
  +    calc_timing(Rest, StageStart, ReplyNow,
  +                [{Stage, timer:now_diff(StageEnd, StageStart)} | Stages]).
   
   %% ===================================================================
   %% EUnit tests
  
positive.code:             Options = flatten_options(proplists:unfold(Options0 ++ ?DEFAULT_OPTS), []),
              StateData2 = handle_options(Options, StateData1),
              StateData = find_fail_threshold(StateData2), 
              {next_state,execute,StateData,0}
      end.
  
  %% @private
  
negative.code: 
  %% @private
  init([From, RObj, Options]) ->
      StateData = add_timing(prepare, #state{from = From,
                                             robj = RObj, 
                                             options = Options}),
      {ok, prepare, StateData, 0};
  init({test, Args, StateProps}) ->
      %% Call normal init
      {ok, prepare, StateData, 0} = init(Args),
  