anchor.diff:  
   # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
   # order to help rehashing the main Redis hash table (the one mapping top-level
  -# keys to values). The hash table implementation redis uses (see dict.c)
  -# performs a lazy rehashing: the more operation you run into an hash table
  -# that is rhashing, the more rehashing steps are performed, so if the
  +# keys to values). The hash table implementation Redis uses (see dict.c)
  +# performs a lazy rehashing: the more operation you run into a hash table
  +# that is rehashing, the more rehashing "steps" are performed, so if the
   # server is idle the rehashing is never complete and some more memory is used
   # by the hash table.
  -#
  +# 
   # The default is to use this millisecond 10 times every second in order to
   # active rehashing the main dictionaries, freeing memory when possible.
   #
   # If unsure:
  -# use activerehashing no if you have hard latency requirements and it is
  +# use "activerehashing no" if you have hard latency requirements and it is
   # not a good thing in your environment that Redis can reply form time to time
   # to queries with 2 milliseconds delay.
   #
  -# use activerehashing yes if you don't have such hard requirements but
  +# use "activerehashing yes" if you don't have such hard requirements but
   # want to free memory asap when possible.
   activerehashing yes
   
  -################################## INCLUDES ###################################
  -
  -# Include one or more other config files here.  This is useful if you
  -# have a standard template that goes to all redis server but also need
  -# to customize a few per-server settings.  Include files can include
  -# other files, so use this wisely.
  -#
  -# include /path/to/local.conf
  -# include /path/to/other.conf
  +# The client output buffer limits can be used to force disconnection of clients
  +# that are not reading data from the server fast enough for some reason (a
  +# common reason is that a Pub/Sub client can't consume messages as fast as the
  +# publisher can produce them).
  +#
  +# The limit can be set differently for the three different classes of clients:
  +#
  +# normal -> normal clients
  +# slave  -> slave clients and MONITOR clients
  +# pubsub -> clients subscribed to at least one pubsub channel or pattern
  +#
  +# The syntax of every client-output-buffer-limit directive is the following:
  +#
  +# client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  +#
  +# A client is immediately disconnected once the hard limit is reached, or if
  +# the soft limit is reached and remains reached for the specified number of
  +# seconds (continuously).
  +# So for instance if the hard limit is 32 megabytes and the soft limit is
  +# 16 megabytes / 10 seconds, the client will get disconnected immediately
  +# if the size of the output buffers reach 32 megabytes, but will also get
  +# disconnected if the client reaches 16 megabytes and continuously overcomes
  +# the limit for 10 seconds.
  +#
  +# By default normal clients are not limited because they don't receive data
  +# without asking (in a push way), but just after a request, so only
  +# asynchronous clients may create a scenario where data is requested faster
  +# than it can read.
  +#
  +# Instead there is a default limit for pubsub and slave clients, since
  +# subscribers and slaves receive data in a push fashion.
  +#
  +# Both the hard or the soft limit can be disabled by setting them to zero.
  +client-output-buffer-limit normal 0 0 0
  +client-output-buffer-limit slave 256mb 64mb 60
  +client-output-buffer-limit pubsub 32mb 8mb 60
  +
  +# Redis calls an internal function to perform many background tasks, like
  +# closing connections of clients in timeout, purging expired keys that are
  +# never requested, and so forth.
  +#
  +# Not all tasks are performed with the same frequency, but Redis checks for
  +# tasks to perform accordingly to the specified "hz" value.
  +#
  +# By default "hz" is set to 10. Raising the value will use more CPU when
  +# Redis is idle, but at the same time will make Redis more responsive when
  +# there are many keys expiring at the same time, and timeouts may be
  +# handled with more precision.
  +#
  +# The range is between 1 and 500, however a value over 100 is usually not
  +# a good idea. Most users should use the default of 10 and raise this up to
  +# 100 only in environments where very low latency is required.
  +hz 10
  +
  +# When a child rewrites the AOF file, if the following option is enabled
  +# the file will be fsync-ed every 32 MB of data generated. This is useful
  +# in order to commit the file to the disk more incrementally and avoid
  +# big latency spikes.
  +aof-rewrite-incremental-fsync yes
positive.code: # that will prevent fsync() from being called in the main process while a
  # BGSAVE or BGREWRITEAOF is in progress.
  #
  # This means that while another child is saving the durability of Redis is
  # the same as appendfsync none, that in pratical terms means that it is
  # possible to lost up to 30 seconds of log in the worst scenario (with the
  # default Linux settings).
  #
  # If you have latency problems turn this to yes. Otherwise leave it as
  # no that is the safest pick from the point of view of durability.
  no-appendfsync-on-rewrite no
  
  # Automatic rewrite of the append only file.
  # Redis is able to automatically rewrite the log file implicitly calling
  # BGREWRITEAOF when the AOF log size will growth by the specified percentage.
  #
  # This is how it works: Redis remembers the size of the AOF file after the
  # latest rewrite (or if no rewrite happened since the restart, the size of
  # the AOF at startup is used).
  #
  # This base size is compared to the current size. If the current size is
  
negative.code: # dbid is a number between 0 and 'databases'-1
  databases <%= @redis_databases %>
  
  ################################ SNAPSHOTTING  ################################
  #
  # Save the DB on disk:
  #
  