anchor.diff:              file:write(FD, io_lib:format(": ~p~n",[Event]))
       end,
       {noreply, State};
  -    
  +
   handle_info(_, State) -> {noreply, State}.
   
   %% @private
  
positive.code:     io_lib:format("[~2..0w/~s/~4..0w:~2..0w:~2..0w:~2..0w ~s]",
                    [Date,month(Month),Year, Hour, Min, Sec, zone()]).
  
  
negative.code: %% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  %% KIND, either express or implied.  See the License for the
  %% specific language governing permissions and limitations
  %% under the License.
  
  %% @doc
  %% riak_event_logger is an example of how to connect to a
  %% running Riak cluster to receive events.
  
  -module(riak_event_logger).
  -behavior(gen_server).
  
  -include_lib("eunit/include/eunit.hrl").
  
  -define (RECONNECT_INTERVAL, 200).
  -define (SERVER, ?MODULE).
  -record (state, {node, pid, fd, is_test=false}).
  -export ([start/2, start_link/2, test_start/2]).
  -export ([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
  
  %% @private
  start(Node, Filename) ->
      gen_server:start({local, ?SERVER}, ?MODULE, [Node, Filename, false], []).
  
  %% @private
  %% For testing only
  test_start(Node, FileName) ->
      gen_server:start({local, ?SERVER}, ?MODULE, [Node, FileName, true], []).
  
  start_link(Node, Filename) ->
      gen_server:start_link({local, ?SERVER}, ?MODULE, [Node, Filename, false], []).
  
  %% @private
  init([Node, Filename, IsTest]) ->
      % If this gen_server dies and is supervised, then it will
      % be restarted under a new pid. If this happens, then we will
      % lose our connection to the Riak cluster. So, send a keepalive
      % every few seconds to reconnect.
      timer:apply_interval(?RECONNECT_INTERVAL, gen_server, call, [?SERVER, connect]),
  
      % Open the file, get the file descriptor....
      {ok, FD} = case Filename of
          _ when Filename == "stdout" orelse Filename == "" ->
              {ok, stdout};
          _ ->
              {ok, CWD} = file:get_cwd(),
              LogFN = filename:join([CWD,Filename]),
              ok = filelib:ensure_dir(LogFN),
              file:open(LogFN, [raw, append, delayed_write])
      end,
  
      State = #state{node = Node,
                     fd = FD,
                     is_test=IsTest},
      {ok, State}.
  
  %% @private
  %% Check if we need to reconnect to the Riak cluster.
  handle_call(connect, _From, State) when State#state.pid /= self() ->
      register_for_events(State),
      {reply, ok, State#state { pid=self() }};
  
  handle_call(_, _, State) -> {reply, ok, State}.
  
  handle_cast(_, State) -> {noreply, State}.
  
  