anchor.diff:      Observers = State#state.observers,
       State1 = State#state{observers=lists:delete(Object,Observers)},
       {next_state, CurState, State1};
  -handle_info({heartbeat, NodeName, NodeStatus},
  +handle_info({heartbeat},
               CurState,
  -            #state{heartbeats=HeartBeats, logging=Level, current_status=CurStatus, heartbeat_rate=HRate}=State) ->
  -    nlog(Level, "Heartbeat recieved from ~p Currently ~p ~p", [NodeName, NodeStatus, HRate]),
  +            #state{name=NodeName, heartbeats_rcvd=HeartBeats, logging=Level, current_status=CurStatus, heartbeat_rate=HRate}=State) ->
  +    nlog(Level, "Heartbeat received from ~p Currently ~p", [NodeName, CurStatus]),
   
       %% Note that we got a heartbeat
  -    State1 = State#state{heartbeat_rate=push_ema:inc(HRate,1), current_status=NodeStatus},
  -    %% Reset the timer
  -    State2 = reset_timer(State1),
  -
  -    case HeartBeats of
  -        ?POC_HB_THRESHOLD - 1 -> % transitioning up
  -            update_status(?SAVE_MODE, NodeStatus, State2),
  -            {next_state, up, State2#state{heartbeats=HeartBeats + 1}};
  -        ?POC_HB_THRESHOLD -> % up, only do something if status changes
  -            case NodeStatus of
  -                CurStatus -> ok;
  -                _Else -> update_status(?SAVE_MODE, NodeStatus, State2)
  -            end,
  -            {next_state, up, State2};
  -        _ -> % we're down, don't save state changes
  -            {next_state, CurState, State2#state{heartbeats=HeartBeats +1}}
  -    end;
  +    State1 = State#state{heartbeat_rate=push_ema:inc(HRate,1), current_status=CurStatus},
  +
  +    {next_state, CurState, State1#state{heartbeats_rcvd=HeartBeats+1}};
   handle_info(down, down, State) ->
       {next_state, down, State};
  -handle_info(down, _CurState, State) ->
  -    {next_state, down, update_status(?SAVE_MODE, down, State#state{heartbeats=0})};
  -handle_info({timeout, _Ref, update_avg}, CurState, #state{heartbeat_rate=HRate}=State) ->
  -    {next_state, CurState, State#state{heartbeat_rate=push_ema:tick(HRate)} };
  -handle_info(no_heartbeats, _CurState, State) ->
  -    State1 = State#state{heartbeats=0, tref=undefined},
  -    update_status(?SAVE_MODE, down, State1),
  -    {next_state, down, State1};
  +handle_info({timeout, _Ref, update_avg}, CurStatus, #state{heartbeat_rate=HRate, up_threshold=UThresh, down_threshold=DThresh}=State) ->
  +    NHRate = pushy_ema:tick(HRate),
  +    EAvg = pushy_ema:value(NHRate),
  +    {NStatus, NState} =
  +        case CurStatus of
  +            up when EAvg < DThresh ->
  +                NS = update_status(down, State),
  +                {down, NS};
  +            down when EAvg > UThresh ->
  +                NS = update_status(up, State),
  +                {up, NS};
  +            S -> {S, State}
  +        end,
  +    {next_state, NStatus, NState#state{heartbeat_rate=NHRate} };
   handle_info(Info, CurState, State) ->
       lager:error("Strange message ~p received in state ~p", [Info, CurState]),
       {next_state, CurState, State}.
  
positive.code:     State1 = case lists:member(Who, Observers) of
          false ->
              erlang:monitor(process, Who),
              State#state{observers=[Who|Observers]};
          true -> State
      end,
      {next_state, StateName, State1};
  
negative.code: %
  % This is split into two phases: an 'upper half' to get the minimimal work done required to wire things up
  % and a 'lower half' that takes care of things that can wait
  %
  init([Name]) ->
      HeartbeatInterval = 1,
      DecayWindow = 5,
      UpThresh   = pushy_util:get_env(push, up_threshold, ?DEFAULT_UP_THRESHOLD, any), %% TODO constrain to float
      DownThresh = pushy_util:get_env(push, down_threshold, ?DEFAULT_DOWN_THRESHOLD, any), %% TODO constrain to float
  
      State = #state{name = Name,
                     decay_window = DecayWindow,
                     heartbeat_interval = HeartbeatInterval,
                     current_status = down, % Fetch from db later
                     heartbeat_rate = pushy_ema:init(HeartbeatInterval, DecayWindow),
                     up_threshold = UpThresh,
                     down_threshold = DownThresh
                    },
      try
          %% The most important thing to have happen is this registration; we need to get this
          %% assigned before anyone else tries to start things up gproc:reg can only return
  