anchor.diff:      io_lib:format("[~2..0w/~s/~4..0w:~2..0w:~2..0w:~2..0w ~s]",
                     [Date,month(Month),Year, Hour, Min, Sec, zone()]).
   
  +%% @private
  +file_write_test() ->
  +    {T1, T2, T3} = erlang:now(),
  +    random:seed(T1, T2, T3),
  +    FileName = "/tmp/event_" ++ integer_to_list(random:uniform(1000)) ++ ".log",
  +    {ok, Pid} = riak_event_logger:test_start(foo, FileName),
  +    Pid ! {event, test_event},
  +    %% Wait for delayed_write to flush
  +    timer:sleep(2100),
  +    exit(Pid, shutdown),
  +    {ok, Data} = file:read_file(FileName),
  +    %file:delete(FileName),
  +    ?assert(size(Data) > 0).
  
positive.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).
  
  -define (RECONNECT_INTERVAL, 200).
  -define (SERVER, ?MODULE).
  -record (state, {node, pid, fd}).
  -export ([start/2, start_link/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], []).
  
  start_link(Node, Filename) -> 
      gen_server:start_link({local, ?SERVER}, ?MODULE, [Node, Filename], []).
  
  %% @private
  init([Node, Filename]) -> 
      % 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),
              io:format("Writing event log to ~p~n",[LogFN]),
              file:open(LogFN, [raw, append, delayed_write])
      end,
      
      State = #state {
          node = Node,
          fd = FD
      },
      {ok, State}.
      
  %% @private
  %% Check if we need to reconnect to the Riak cluster.
  handle_call(connect, _From, State) ->
      PidHasChanged = State#state.pid /= self(),
      case PidHasChanged of
          true ->  register_for_events(State);
          false -> ignore
      end,
      {reply, ok, State#state { pid=self() }};
      
  handle_call(_, _, State) -> {ok, State}.
  
  handle_cast(_, State) -> {noreply, State}.
  
  
negative.code: %% @private
  code_change(_OldVsn, State, _Extra) -> {ok, State}.
  
  register_for_events(State) when State#state.is_test =:= false ->
      % Get the client...
      {ok, C} = riak:client_connect(State#state.node),
  
      % Attach the eventer...
      Desc = io_lib:format("~s", [?SERVER]),
      C:add_event_handler(self(), Desc, {'_', '_', '_', '_'}, []);
  register_for_events(_State) ->
    ok.
  
  
  %%% DATE FUNCTIONS %%%
  