anchor.diff:  handle_info(beat, State) ->
       NewState = disarm_forced_beat_timer(State),
       misc:flush(beat),
  -    heartbeat(current_status(NewState#state.expensive_checks_result)),
  +    heartbeat(current_status()),
       {noreply, NewState};
  -handle_info(do_expensive_checks, State) ->
  -    {noreply, State#state{expensive_checks_result = expensive_checks()}};
   handle_info(force_beat, State) ->
       {noreply, arm_forced_beat_timer(State)};
   handle_info(_, State) ->
  
positive.code:                             end
                      end, [], BucketNames),
  
      failover_safeness_level:build_local_safeness_info(BucketNames) ++
          [{active_buckets, ns_memcached:active_buckets()},
           {ready_buckets, ns_memcached:connected_buckets()},
           {memory, erlang:memory()},
           {system_stats, [{N, proplists:get_value(N, SystemStats, 0)}
                           || N <- [cpu_utilization_rate, swap_total, swap_used]]},
           {interesting_stats, InterestingStats},
           {cluster_compatibility_version, ClusterCompatVersion}
           | element(2, ns_info:basic_info())] ++ Expensive.
  
  
  expensive_checks() ->
      BasicData = [{system_memory_data, memsup:get_system_memory_data()},
                   {statistics, stats()}],
      case misc:raw_read_file("/proc/meminfo") of
          {ok, Contents} ->
              [{meminfo, Contents} | BasicData];
          _ -> BasicData
      end.
  
  %% returns dict as if returned by ns_doctor:get_nodes/0 but containing only
  %% failover safeness fields (or down bool property). Instead of going
  
negative.code: 
  
  handle_call(status, _From, State) ->
      {reply, current_status(), State};
  handle_call(Request, _From, State) ->
      {reply, {unhandled, ?MODULE, Request}, State}.
  
  