Provided by: erlang-manpages_16.b.3-dfsg-1ubuntu2_all bug

NAME

       rb - The Report Browser Tool

DESCRIPTION

       The  Report Browser (RB) tool makes it possible to browse and format error reports written
       by the error logger handler log_mf_h.

EXPORTS

       filter(Filters)
       filter(Filters, Dates)

              Types:

                 Filters = [filter()]
                 filter() = {Key, Value} | {Key, Value, no} | {Key, RegExp, re} |  {Key,  RegExp,
                 re, no}
                 Key = term()
                 Value = term()
                 RegExp = string() | {string, Options} | mp(), {mp(), Options}
                 Dates = {DateFrom, DateTo} | {DateFrom, from} | {DateTo, to}
                 DateFrom = DateTo = {date(), time()}
                 date() and time() are the same type as in the calendar module

              This function displays the reports that match the provided filters.

              When  a  filter  includes  the  no atom it will exclude the reports that match that
              filter.

              The reports are matched using the proplists module. The report must be  a  proplist
              to be matched against any of the filters().

              If  the  filter is of the form {Key, RegExp, re} the report must contain an element
              with key = Key and Value must match the RegExp regular expression.

              If the Dates parameter is provided, then the reports are filtered according to  the
              date when they occurred. If Dates is of the form {DateFrom, from} then reports that
              occurred after DateFrom are displayed.

              If Dates is of the form {DateTo, to} then reports that occurred before  DateTo  are
              displayed.

              If  two  Dates  are  provided,  then  reports that occurred between those dates are
              returned.

              If you only want to filter only by dates, then you can provide the  empty  list  as
              the Filters parameter.

              See rb:grep/1 for more information on the RegExp parameter.

       grep(RegExp)

              Types:

                 RegExp = string() | {string, Options} | mp(), {mp(), Options}

              All reports containing the regular expression RegExp are printed.

              RegExp  can  be a string containing the regular expression; a tuple with the string
              and the options for compilation; a compiled regular expression; a compiled  regular
              expression and the options for running it. Refer to the module re and specially the
              function re:run/3 for a definition of valid regular expressions and options.

       h()
       help()

              Prints the on-line help information.

       list()
       list(Type)

              Types:

                 Type = type()
                 type() =  error  |  error_report  |  info_msg  |  info_report  |  warning_msg  |
                 warning_report | crash_report | supervisor_report | progress

              This  function  lists  all  reports loaded in the rb_server. Each report is given a
              unique number that can be used as a reference to the report in the show/1 function.

              If no Type is given, all reports are listed.

       log_list()
       log_list(Type)

              Types:

                 Type = type()
                 type() =  error  |  error_report  |  info_msg  |  info_report  |  warning_msg  |
                 warning_report | crash_report | supervisor_report | progress

              Same  as  list/0  or  list/1  functions  but  result is printed to logfile, if set,
              otherwise to standard_io.

              If no Type is given, all reports are listed.

       rescan()
       rescan(Options)

              Types:

                 Options = [opt()]

              Rescans the report directory. Options is the same as for start().

       show()
       show(Report)

              Types:

                 Report = int() | type()

              If a type argument is given, all loaded reports of this type  are  printed.  If  an
              integer  argument is given, the report with this reference number is printed. If no
              argument is given, all reports are shown.

       start()
       start(Options)

              Types:

                 Options = [opt()]
                 opt() = {start_log, FileName} | {max, MaxNoOfReports} | {report_dir,  DirString}
                 | {type, ReportType} | {abort_on_error, Bool}
                 FileName = string() | atom() | pid()
                 MaxNoOfReports = int() | all
                 DirString = string()
                 ReportType = type() | [type()] | all
                 Bool = true | false

              The function start/1 starts the rb_server with the specified options, while start/0
              starts with default options. The rb_server must be started before  reports  can  be
              browsed.  When  the  rb_server is started, the files in the specified directory are
              scanned. The other functions assume that the server has started.

              {start_log, FileName} starts logging to file, registered  name  or  io_device.  All
              reports  will  be printed to the named file. The default is standard_io. The option
              {start_log, standard_error}  is  not  allowed  and  will  be  replaced  by  default
              standard_io.

              {max,  MaxNoOfReports}.  Controls  how  many  reports  the rb_server should read on
              start-up. This option is useful as the directory may  contain  20.000  reports.  If
              this  option  is given, the MaxNoOfReports latest reports will be read. The default
              is 'all'.

              {report_dir, DirString}. Defines the  directory  where  the  error  log  files  are
              located. The default is {sasl, error_logger_mf_dir}.

              {type,  ReportType}.  Controls  what  kind  of reports the rb_server should read on
              start-up. ReportType is a supported type, 'all', or a list of supported types.  The
              default is 'all'.

              {abort_on_error,  Bool}.  This  option  specifies  whether or not logging should be
              aborted if rb encounters an unprintable report. (You may get a report on  incorrect
              form  if  the  error_logger  function error_msg or info_msg has been called with an
              invalid format string). If Bool is true, rb will stop logging (and print  an  error
              message to stdout) if it encounters a badly formatted report. If logging to file is
              enabled, an error message will be appended to the log file  as  well.  If  Bool  is
              false  (which  is  the default value), rb will print an error message to stdout for
              every bad report it encounters, but the  logging  process  is  never  aborted.  All
              printable  reports  will  be  written.  If  logging to file is enabled, rb prints *
              UNPRINTABLE REPORT * in the log file at the location of an unprintable report.

       start_log(FileName)

              Types:

                 FileName = string() | atom() | pid()

              Redirects all report output from the RB tool to the specified file, registered name
              or io_device.

       stop()

              Stops the rb_server.

       stop_log()

              Closes the log file. The output from the RB tool will be directed to standard_io.