anchor.diff:                      server_port = Port}, InstanceId]) ->
       IncarnationId = list_to_binary(pushy_util:guid_v4()),
   
  -    lager:info("Getting config from Pushy Server ~s:~w", [Hostname, Port]),
  -    Config = pushy_client_config:get_config(?PUSHY_ORGNAME, Hostname, Port),
  -    Interval =  pushy_util:get_env(pushysim, heartbeat_interval, fun is_integer/1),
  +    lager:debug("Getting config from Pushy Server ~s:~w", [Hostname, Port]),
  +    #pushy_client_config{command_address = CommandAddress,
  +                         heartbeat_address = HeartbeatAddress,
  +                         heartbeat_interval = Interval,
  +                         server_public_key = PublicKey } = ?TIME_IT(pushy_client_config, get_config,
  +                                                                    (?PUSHY_ORGNAME, Hostname, Port)),
   
       NodeId = list_to_binary(io_lib:format("~s-~4..0B", [ClientName, InstanceId])),
       lager:info("Starting pushy client with node id ~s (~s).", [NodeId, IncarnationId]),
   
   
  -    HeartbeatAddress = proplists:get_value(heartbeat_address, Config),
  -    {ok, HeartbeatSock} = connect_to_heartbeat(Ctx, HeartbeatAddress),
  -    CommandAddress = proplists:get_value(command_address, Config),
  -    {ok, CommandSock} = connect_to_command(Ctx, CommandAddress),
  +    {ok, HeartbeatSock} = ?TIME_IT(?MODULE, connect_to_heartbeat, (Ctx, HeartbeatAddress)),
  +    {ok, CommandSock} = ?TIME_IT(?MODULE, connect_to_command, (Ctx, CommandAddress)),
   
       {ok, PrivateKey} = chef_keyring:get_key(client_private),
  -    {ok, PublicKey} = server_public_key(Config),
   
       State = #state{command_sock = CommandSock,
                      heartbeat_sock = HeartbeatSock,
  
positive.code: %% ------------------------------------------------------------------
  %% Internal Function Definitions
  %% ------------------------------------------------------------------
  
  server_public_key(Config) ->
      RawKey = proplists:get_value(public_key, Config),
      case chef_authn:extract_public_or_private_key(RawKey) of
          {error, bad_key} ->
              lager:error("Can't decode Public Key ~s~n", [RawKey]),
              {error, bad_key};
           Key when is_tuple(Key) ->
              {ok, Key}
      end.
  
  -spec send_heartbeat(#state{}) -> #state{}.
  send_heartbeat(#state{command_sock = Sock,
  
negative.code:     lager:debug("Heartbeat sent: header=~s,body=~s",[HeaderFrame, BodyFrame]),
      State#state{sequence=Sequence + 1}.
  
  -spec send_response(Type :: binary(),
                      JobId :: binary(),
                      State :: #state{}) -> #state{}.
  send_response(Type, JobId, #state{command_sock = Sock,
                                    client_name = ClientName,
                                    private_key = PrivateKey,
                                    incarnation_id = IncarnationId,
                                    node_id = NodeId} = State) ->
      lager:debug("Sending response for ~s : ~s", [NodeId, Type]),
      Msg = {[{node, NodeId},
              {client, ClientName},
              {org, "pushy"},
  