doc/rrdcached.pod

   1 =pod
   2
   3 =head1 NAME
   4
   5 rrdcached - Data caching daemon for rrdtool
   6
   7 =head1 SYNOPSIS
   8
   9 B<rrdcached>
  10 [B<-P>E<nbsp>I<permissions>]
  11 [B<-l>E<nbsp>I<address>]
  12 [B<-s>E<nbsp>I<group>]
  13 [B<-w>E<nbsp>I<timeout>]
  14 [B<-z>E<nbsp>I<delay>]
  15 [B<-f>E<nbsp>I<timeout>]
  16 [B<-p>E<nbsp>I<pid_file>]
  17 [B<-t>E<nbsp>I<write_threads>]
  18 [B<-j>E<nbsp>I<journal_dir>]
  19 [-F]
  20 [-g]
  21 [B<-b>E<nbsp>I<base_dir>E<nbsp>[B<-B>]]
  22
  23 =head1 DESCRIPTION
  24
  25 B<rrdcached> is a daemon that receives updates to existing RRD files,
  26 accumulates them and, if enough have been received or a defined time has
  27 passed, writes the updates to the RRD file. A I<flush> command may be used to
  28 force writing of values to disk, so that graphing facilities and similar can
  29 work with up-to-date data.
  30
  31 The daemon was written with big setups in mind. Those setups usually run into
  32 IOE<nbsp>related problems sooner or later for reasons that are beyond the scope
  33 of this document. Check the wiki at the RRDtool homepage for details. Also
  34 check L</"SECURITY CONSIDERATIONS"> below before using this daemon! A detailed
  35 description of how the daemon operates can be found in the L</"HOW IT WORKS">
  36 section below.
  37
  38 =head1 OPTIONS
  39
  40 =over 4
  41
  42 =item B<-l> I<address>
  43
  44 Tells the daemon to bind to I<address> and accept incoming connections on that
  45 socket. If I<address> begins with C<unix:>, everything following that prefix is
  46 interpreted as the path to a UNIX domain socket. Otherwise the address or node
  47 name are resolved using C<getaddrinfo()>.
  48
  49 For network sockets, a port may be specified by using the form
  50 C<B<[>I<address>B<]:>I<port>>. If the address is an IPv4 address or a fully
  51 qualified domain name (i.E<nbsp>e. the address contains at least one dot
  52 (C<.>)), the square brackets can be omitted, resulting in the (simpler)
  53 C<I<address>B<:>I<port>> pattern. The default port is B<42217/tcp>. If you
  54 specify a network socket, it is mandatory to read the
  55 L</"SECURITY CONSIDERATIONS"> section.
  56
  57 The following formats are accepted. Please note that the address of the UNIX
  58 domain socket B<must> start with a slash in the second case!
  59
  60    unix:</path/to/unix.sock>
  61    /<path/to/unix.sock>
  62    <hostname-or-ip>
  63    [<hostname-or-ip>]:<port>
  64    <hostname-or-ipv4>:<port>
  65
  66 If the B<-l> option is not specified the default address,
  67 C<unix:/tmp/rrdcached.sock>, will be used.
  68
  69 =item B<-s> I<group_name>|I<gid>
  70
  71 Set the group permissions of a UNIX domain socket. The option accepts either
  72 a numeric group id or group name. That group will then have both read and write
  73 permissions (the socket will have file permissions 0750) for the socket and,
  74 therefore, is able to send commands to the daemon. This
  75 may be useful in cases where you cannot easily run all RRD processes with the same
  76 user privileges (e.g. graph generating CGI scripts that typically run in the
  77 permission context of the web server).
  78
  79 This option affects the I<following> UNIX socket addresses (the following
  80 B<-l> options) or the default socket (if no B<-l> options have been
  81 specified), i.e., you may specify different settings for different
  82 sockets.
  83
  84 The default is not to change ownership or permissions of the socket and, thus,
  85 use the system default.
  86
  87 =item B<-m> I<mode>
  88
  89 Set the file permissions of a UNIX domain socket. The option accepts an octal
  90 number representing the bit pattern for the mode (see L<chmod(1)> for
  91 details).
  92
  93 Please note that not all systems honor this setting. On Linux, read/write
  94 permissions are required to connect to a UNIX socket. However, many
  95 BSD-derived systems ignore permissions for UNIX sockets. See L<unix(7)> for
  96 details.
  97
  98 This option affects the I<following> UNIX socket addresses (the following
  99 B<-l> options) or the default socket (if no B<-l> options have been
 100 specified), i.e., you may specify different settings for different
 101 sockets.
 102
 103 The default is not to change ownership or permissions of the socket and, thus,
 104 use the system default.
 105
 106 =item B<-P> I<command>[,I<command>[,...]]
 107
 108 Specifies the commands accepted via a network socket. This allows
 109 administrators of I<RRDCacheD> to control the actions accepted from various
 110 sources.
 111
 112 The arguments given to the B<-P> option is a comma separated list of commands.
 113 For example, to allow the C<FLUSH> and C<PENDING> commands one could specify:
 114
 115   rrdcached -P FLUSH,PENDING $MORE_ARGUMENTS
 116
 117 The B<-P> option affects the I<following> socket addresses (the following B<-l>
 118 options) or the default socket (if no B<-l> options have been
 119 specified). In the following example, only the IPv4 network socket (address
 120 C<10.0.0.1>) will be restricted to the C<FLUSH> and C<PENDING> commands:
 121
 122   rrdcached -l unix:/some/path -P FLUSH,PENDING -l 10.0.0.1
 123
 124 A complete list of available commands can be found in the section
 125 L</"Valid Commands"> below. There are two minor special exceptions:
 126
 127 =over 4
 128
 129 =item *
 130
 131 The C<HELP> and C<QUIT> commands are always allowed.
 132
 133 =item *
 134
 135 If the C<BATCH> command is accepted, the B<.>E<nbsp>command will automatically
 136 be accepted, too.
 137
 138 =back
 139
 140 Please also read L</"SECURITY CONSIDERATIONS"> below.
 141
 142 =item B<-w> I<timeout>
 143
 144 Data is written to disk every I<timeout> seconds. If this option is not
 145 specified the default interval of 300E<nbsp>seconds will be used.
 146
 147 =item B<-z> I<delay>
 148
 149 If specified, rrdcached will delay writing of each RRD for a random number
 150 of seconds in the rangeE<nbsp>[0,I<delay>).  This will avoid too many
 151 writes being queued simultaneously.  This value should be no greater than
 152 the value specified in B<-w>.  By default, there is no delay.
 153
 154 =item B<-f> I<timeout>
 155
 156 Every I<timeout> seconds the entire cache is searched for old values which are
 157 written to disk. This only concerns files to which updates have stopped, so
 158 setting this to a high value, such as 3600E<nbsp>seconds, is acceptable in most
 159 cases. This timeout defaults to 3600E<nbsp>seconds.
 160
 161 =item B<-p> I<file>
 162
 163 Sets the name and location of the PID-file. If not specified, the default,
 164 C<I<$localststedir>/run/rrdcached.pid> will be used.
 165
 166 =item B<-t> I<write_threads>
 167
 168 Specifies the number of threads used for writing RRD files.  The default
 169 isE<nbsp>4.  Increasing this number will allow rrdcached to have more
 170 simultaneous I/O requests into the kernel.  This may allow the kernel to
 171 re-order disk writes, resulting in better disk throughput.
 172
 173 =item B<-j> I<dir>
 174
 175 Write updates to a journal in I<dir>.  In the event of a program or system
 176 crash, this will allow the daemon to write any updates that were pending
 177 at the time of the crash.
 178
 179 On startup, the daemon will check for journal files in this directory.  If
 180 found, all updates therein will be read into memory before the daemon
 181 starts accepting new connections.
 182
 183 The journal will be rotated with the same frequency as the flush timer
 184 given by B<-f>.
 185
 186 When journaling is enabled, the daemon will use a fast shutdown procedure.
 187 Rather than flushing all files to disk, it will make sure the journal is
 188 properly written and exit immediately.  Although the RRD data files are
 189 not fully up-to-date, no information is lost; all pending updates will be
 190 replayed from the journal next time the daemon starts up.
 191
 192 To disable fast shutdown, use the B<-F> option.
 193
 194 =item B<-F>
 195
 196 ALWAYS flush all updates to the RRD data files when the daemon is shut
 197 down, regardless of journal setting.
 198
 199 =item B<-g>
 200
 201 Run in the foreground.  The daemon will not fork().
 202
 203 =item B<-b> I<dir>
 204
 205 The daemon will change into a specific directory at startup. All files passed
 206 to the daemon, that are specified by a B<relative> path, will be interpreted
 207 to be relative to this directory. If not given the default, C</tmp>, will be
 208 used.
 209
 210   +------------------------+------------------------+
 211   ! Command line           ! File updated           !
 212   +------------------------+------------------------+
 213   ! foo.rrd                ! /tmp/foo.rrd           !
 214   ! foo/bar.rrd            ! /tmp/foo/bar.rrd       !
 215   ! /var/lib/rrd/foo.rrd   ! /var/lib/rrd/foo.rrd   !
 216   +------------------------+------------------------+
 217   Paths given on the command  line and paths actually
 218   updated by the daemon,  assuming the base directory
 219   "/tmp".
 220
 221 B<WARNING:> The paths up to and including the base directory B<MUST NOT BE>
 222 symbolic links.  In other words, if the base directory is
 223 specified as:
 224
 225     -b /base/dir/somewhere
 226
 227 ... then B<NONE> of the following should be symbolic links:
 228
 229     /base
 230     /base/dir
 231     /base/dir/somewhere
 232
 233 =item B<-B>
 234
 235 Only permit writes into the base directory specified in B<-b> (and any
 236 sub-directories).  This does B<NOT> detect symbolic links.  Paths
 237 containing C<../> will also be blocked.
 238
 239 =back
 240
 241 =head1 AFFECTED RRDTOOL COMMANDS
 242
 243 The following commands may be made aware of the B<rrdcached> using the command
 244 line argument B<--daemon> or the environment variable B<RRDCACHED_ADDRESS>:
 245
 246 =over
 247
 248 =item *
 249
 250 dump
 251
 252 =item *
 253
 254 fetch
 255
 256 =item *
 257
 258 flush
 259
 260 =item *
 261
 262 graph
 263
 264 =item *
 265
 266 graphv
 267
 268 =item *
 269
 270 info
 271
 272 =item *
 273
 274 last
 275
 276 =item *
 277
 278 lastupdate
 279
 280 =item *
 281
 282 update
 283
 284 =item *
 285
 286 xport
 287
 288 =back
 289
 290 The B<update> command can send values to the daemon instead of writing them to
 291 the disk itself. All other commands can send a B<FLUSH> command (see below) to
 292 the daemon before accessing the files, so they work with up-to-date data even
 293 if the cache timeout is large.
 294
 295 =head1 ERROR REPORTING
 296
 297 The daemon reports errors in one of two ways: During startup, error messages
 298 are printed to C<STDERR>. One of the steps when starting up is to fork to the
 299 background and closing C<STDERR> - after this writing directly to the user is
 300 no longer possible. Once this has happened, the daemon will send log messages
 301 to the system logging daemon using syslog(3). The facility used is
 302 C<LOG_DAEMON>.
 303
 304 =head1 HOW IT WORKS
 305
 306 When receiving an update, B<rrdcached> does not write to disk but looks for an
 307 entry for that file in its internal tree. If not found, an entry is created
 308 including the current time (called "First" in the diagram below). This time is
 309 B<not> the time specified on the command line but the time the operating system
 310 considers to be "now". The value and time of the value (called "Time" in the
 311 diagram below) are appended to the tree node.
 312
 313 When appending a value to a tree node, it is checked whether it's time to write
 314 the values to disk. Values are written to disk if
 315 S<C<now() - First E<gt>= timeout>>, where C<timeout> is the timeout specified
 316 using the B<-w> option, see L</OPTIONS>. If the values are "old enough" they
 317 will be enqueued in the "update queue", i.E<nbsp>e. they will be appended to
 318 the linked list shown below.  Because the tree nodes and the elements of the
 319 linked list are the same data structures in memory, any update to a file that
 320 has already been enqueued will be written with the next write to the RRD file,
 321 too.
 322
 323 A separate "update thread" constantly dequeues the first element in the update
 324 queue and writes all its values to the appropriate file. So as long as the
 325 update queue is not empty files are written at the highest possible rate.
 326
 327 Since the timeout of files is checked only when new values are added to the
 328 file, "dead" files, i.E<nbsp>e. files that are not updated anymore, would never
 329 be written to disk. Therefore, every now and then, controlled by the B<-f>
 330 option, the entire tree is walked and all "old" values are enqueued. Since this
 331 only affects "dead" files and walking the tree is relatively expensive, you
 332 should set the "flush interval" to a reasonably high value. The default is
 333 3600E<nbsp>seconds (one hour).
 334
 335 The downside of caching values is that they won't show up in graphs generated
 336 from the RRDE<nbsp>files. To get around this, the daemon provides the "flush
 337 command" to flush specific files. This means that the file is inserted at the
 338 B<head> of the update queue or moved there if it is already enqueued. The flush
 339 command will return only after the file's pending updates have been written
 340 to disk.
 341
 342  +------+   +------+                               +------+
 343  ! head !   ! root !                               ! tail !
 344  +---+--+   +---+--+                               +---+--+
 345      !         /\                                      !
 346      !        /  \                                     !
 347      !       /\  /\                                    !
 348      !      /\/\ \ `----------------- ... --------,    !
 349      V     /      `-------,                       !    V
 350  +---+----+---+    +------+-----+             +---+----+---+
 351  ! File:  foo !    ! File:  bar !             ! File:  qux !
 352  ! First: 101 !    ! First: 119 !             ! First: 180 !
 353  ! Next:&bar -+--->! Next:&... -+---> ... --->! Next:NULL  !
 354  | Prev:NULL  !<---+-Prev:&foo  !<--- ... ----+-Prev: &... !
 355  +============+    +============+             +============+
 356  ! Time:  100 !    ! Time:  120 !             ! Time:  180 !
 357  ! Value:  10 !    ! Value: 0.1 !             ! Value: 2,2 !
 358  +------------+    +------------+             +------------+
 359  ! Time:  110 !    ! Time:  130 !             ! Time:  190 !
 360  ! Value:  26 !    ! Value: 0.1 !             ! Value: 7,3 !
 361  +------------+    +------------+             +------------+
 362  :            :    :            :             :            :
 363  +------------+    +------------+             +------------+
 364  ! Time:  230 !    ! Time:  250 !             ! Time:  310 !
 365  ! Value:  42 !    ! Value: 0.2 !             ! Value: 1,2 !
 366  +------------+    +------------+             +------------+
 367
 368 The above diagram demonstrates:
 369
 370 =over
 371
 372 =item *
 373
 374 Files/values are stored in a (balanced) tree.
 375
 376 =item *
 377
 378 Tree nodes and entries in the update queue are the same data structure.
 379
 380 =item *
 381
 382 The local time ("First") and the time specified in updates ("Time") may differ.
 383
 384 =item *
 385
 386 Timed out values are inserted at the "tail".
 387
 388 =item *
 389
 390 Explicitly flushed values are inserted at the "head".
 391
 392 =item *
 393
 394 ASCII art rocks.
 395
 396 =back
 397
 398 =head1 SECURITY CONSIDERATIONS
 399
 400 =head2 Authentication
 401
 402 If your rrdtool installation was built without libwrap there is no form of
 403 authentication for clients connecting to the rrdcache daemon!
 404
 405 If your rrdtool installation was built with libwrap then you can use
 406 hosts_access to restrict client access to the rrdcache daemon (rrdcached).  For more
 407 information on how to use hosts_access to restrict access to the rrdcache
 408 daemon you should read the hosts_access(5) man pages.
 409
 410 It is still highly recommended to install a packet filter or similar mechanism to
 411 prevent unauthorized connections. Unless you have a dedicated VLAN or VPN for
 412 this, using network sockets is probably a bad idea!
 413
 414 =head2 Authorization
 415
 416 There is minimal per-socket authorization.
 417
 418 Authorization is currently done on a per-socket basis. That means each socket
 419 has a list of commands it will accept and it will accept. It will accept only
 420 those commands explicitly listed but it will (currently) accept these commands
 421 from anyone reaching the socket.
 422
 423 If the networking sockets are to be used, it is necessary to restrict the
 424 accepted commands to those needed by external clients. If, for example,
 425 external clients want to draw graphs of the cached data, they should only be
 426 allowed to use the C<FLUSH> command.
 427
 428 =head2 Encryption
 429
 430 There is no encryption.
 431
 432 Again, this may be added in the future, but for the time being it is your job
 433 to keep your private data private. Install a VPN or an encrypted tunnel if you
 434 statistics are confidential!
 435
 436 =head2 Sanity checking
 437
 438 There is no sanity checking.
 439
 440 The daemon will blindly write to any file it gets told, so you really should
 441 create a separate user just for this daemon. Also it does not do any sanity
 442 checks, so if it gets told to write values for a time far in the future, your
 443 files will be messed up good!
 444
 445 =head2 Conclusion
 446
 447 =over 4
 448
 449 =item *
 450
 451 Security is the job of the administrator.
 452
 453 =item *
 454
 455 We recommend to allow write access via UNIX domain sockets only.
 456
 457 =item *
 458
 459 You have been warned.
 460
 461 =back
 462
 463 =head1 PROTOCOL
 464
 465 The daemon communicates with clients using a line based ASCII protocol which is
 466 easy to read and easy to type. This makes it easy for scripts to implement the
 467 protocol and possible for users to use telnet to connect to the daemon
 468 and test stuff "by hand".
 469
 470 The protocol is line based, this means that each record consists of one or more
 471 lines. A line is terminated by the line feed character C<0x0A>, commonly
 472 written as C<\n>. In the examples below, this character will be written as
 473 C<E<lt>LFE<gt>> ("line feed").
 474
 475 After the connection has been established, the client is expected to send a
 476 "command". A command consists of the command keyword, possibly some arguments,
 477 and a terminating newline character. For a list of commands, see
 478 L</"Valid Commands"> below.
 479
 480 Example:
 481
 482   FLUSH /tmp/foo.rrd<LF>
 483
 484 The daemon answers with a line consisting of a status code and a short status
 485 message, separated by one or more space characters. A negative status code
 486 signals an error, a positive status code or zero signal success. If the status
 487 code is greater than zero, it indicates the number of lines that follow the
 488 status line.
 489
 490 Examples:
 491
 492  0 Success<LF>
 493
 494  2 Two lines follow<LF>
 495  This is the first line<LF>
 496  And this is the second line<LF>
 497
 498 =head2 Valid Commands
 499
 500 The following commands are understood by the daemon:
 501
 502 =over 4
 503
 504 =item B<FLUSH> I<filename>
 505
 506 Causes the daemon to put I<filename> to the B<head> of the update queue
 507 (possibly moving it there if the node is already enqueued). The answer will be
 508 sent B<after> the node has been dequeued.
 509
 510 =item B<FLUSHALL>
 511
 512 Causes the daemon to start flushing ALL pending values to disk.  This
 513 returns immediately, even though the writes may take a long time.
 514
 515 =item B<PENDING> I<filename>
 516
 517 Shows any "pending" updates for a file, in order.  The updates shown have
 518 not yet been written to the underlying RRD file.
 519
 520 =item B<FORGET> I<filename>
 521
 522 Removes I<filename> from the cache.  Any pending updates B<WILL BE LOST>.
 523
 524 =item B<QUEUE>
 525
 526 Shows the files that are on the output queue.  Returns zero or more lines
 527 in the following format, where E<lt>num_valsE<gt> is the number of values
 528 to be written for the E<lt>fileE<gt>:
 529
 530     <num_vals> <file>
 531
 532 =item B<HELP> [I<command>]
 533
 534 Returns a short usage message. If no command is given, or I<command> is
 535 B<HELP>, a list of commands supported by the daemon is returned. Otherwise a
 536 short description, possibly containing a pointer to a manual page, is returned.
 537 Obviously, this is meant for interactive usage and the format in which the
 538 commands and usage summaries are returned is not well defined.
 539
 540 =item B<STATS>
 541
 542 Returns a list of metrics which can be used to measure the daemons performance
 543 and check its status. For a description of the values returned, see
 544 L</"Performance Values"> below.
 545
 546 The format in which the values are returned is similar to many other line based
 547 protocols: Each value is printed on a separate line, each consisting of the
 548 name of the value, a colon, one or more spaces and the actual value.
 549
 550 Example:
 551
 552  9 Statistics follow
 553  QueueLength: 0
 554  UpdatesReceived: 30
 555  FlushesReceived: 2
 556  UpdatesWritten: 13
 557  DataSetsWritten: 390
 558  TreeNodesNumber: 13
 559  TreeDepth: 4
 560  JournalBytes: 190
 561  JournalRotate: 0
 562
 563 =item B<UPDATE> I<filename> I<values> [I<values> ...]
 564
 565 Adds more data to a filename. This is B<the> operation the daemon was designed
 566 for, so describing the mechanism again is unnecessary. Read L</"HOW IT WORKS">
 567 above for a detailed explanation.
 568
 569 Note that rrdcached only accepts absolute timestamps in the update values.
 570 Updates strings like "N:1:2:3" are automatically converted to absolute
 571 time by the RRD client library before sending to rrdcached.
 572
 573 =item B<WROTE> I<filename>
 574
 575 This command is written to the journal after a file is successfully
 576 written out to disk.  It is used during journal replay to determine which
 577 updates have already been applied.  It is I<only> valid in the journal; it
 578 is not accepted from the other command channels.
 579
 580 =item B<BATCH>
 581
 582 This command initiates the bulk load of multiple commands.  This is
 583 designed for installations with extremely high update rates, since it
 584 permits more than one command to be issued per read() and write().
 585
 586 All commands are executed just as they would be if given individually,
 587 except for output to the user.  Messages indicating success are
 588 suppressed, and error messages are delayed until the client is finished.
 589
 590 Command processing is finished when the client sends a dot (".") on its
 591 own line.  After the client has finished, the server responds with an
 592 error count and the list of error messages (if any).  Each error messages
 593 indicates the number of the command to which it corresponds, and the error
 594 message itself.  The first user command after B<BATCH> is command number one.
 595
 596     client:  BATCH
 597     server:  0 Go ahead.  End with dot '.' on its own line.
 598     client:  UPDATE x.rrd 1223661439:1:2:3            <--- command #1
 599     client:  UPDATE y.rrd 1223661440:3:4:5            <--- command #2
 600     client:  and so on...
 601     client:  .
 602     server:  2 Errors
 603     server:  1 message for command 1
 604     server:  12 message for command 12
 605
 606 =item B<QUIT>
 607
 608 Disconnect from rrdcached.
 609
 610 =back
 611
 612 =head2 Performance Values
 613
 614 The following counters are returned by the B<STATS> command:
 615
 616 =over 4
 617
 618 =item B<QueueLength> I<(unsigned 64bit integer)>
 619
 620 Number of nodes currently enqueued in the update queue.
 621
 622 =item B<UpdatesReceived> I<(unsigned 64bit integer)>
 623
 624 Number of UPDATE commands received.
 625
 626 =item B<FlushesReceived> I<(unsigned 64bit integer)>
 627
 628 Number of FLUSH commands received.
 629
 630 =item B<UpdatesWritten> I<(unsigned 64bit integer)>
 631
 632 Total number of updates, i.E<nbsp>e. calls to C<rrd_update_r>, since the
 633 daemon was started.
 634
 635 =item B<DataSetsWritten> I<(unsigned 64bit integer)>
 636
 637 Total number of "data sets" written to disk since the daemon was
 638 started. A data set is one or more values passed to the B<UPDATE>
 639 command. For example: C<1223661439:123:456> is one data set with two
 640 values. The term "data set" is used to prevent confusion whether
 641 individual values or groups of values are counted.
 642
 643 =item B<TreeNodesNumber> I<(unsigned 64bit integer)>
 644
 645 Number of nodes in the cache.
 646
 647 =item B<TreeDepth> I<(unsigned 64bit integer)>
 648
 649 Depth of the tree used for fast key lookup.
 650
 651 =item B<JournalBytes> I<(unsigned 64bit integer)>
 652
 653 Total number of bytes written to the journal since startup.
 654
 655 =item B<JournalRotate> I<(unsigned 64bit integer)>
 656
 657 Number of times the journal has been rotated since startup.
 658
 659 =back
 660
 661 =head1 SIGNALS
 662
 663 =over 4
 664
 665 =item SIGINT and SIGTERM
 666
 667 The daemon exits normally on receipt of either of these signals.  Pending
 668 updates are handled in accordance with the B<-j> and B<-F> options.
 669
 670 =item SIGUSR1
 671
 672 The daemon exits AFTER flushing all updates out to disk.  This may take a
 673 while.
 674
 675 =item SIGUSR2
 676
 677 The daemon exits immediately, without flushing updates out to disk.
 678 Pending updates will be replayed from the journal when the daemon starts
 679 up again.  B<WARNING: if journaling (-j) is NOT enabled, any pending
 680 updates WILL BE LOST>.
 681
 682 =back
 683
 684 =head1 BUGS
 685
 686 No known bugs at the moment.
 687
 688 =head1 SEE ALSO
 689
 690 L<rrdtool>, L<rrdgraph>
 691
 692 =head1 AUTHOR
 693
 694 Florian Forster E<lt>octoE<nbsp>atE<nbsp>verplant.orgE<gt>
 695
 696 Both B<rrdcached> and this manual page have been written by Florian.
 697
 698 =head1 CONTRIBUTORS
 699
 700 kevin brintnall E<lt>kbrint@rufus.netE<gt>
 701
 702 =cut
 703