NAME

       rb - The Report Browser Tool

DESCRIPTION

       The  Report  Browser  (RB)  tool  is  used to browse and format error reports written by the error logger
       handler log_mf_h in STDLIB.

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} | re:mp() | {re:mp(), Options}
                 Dates = {DateFrom, DateTo} | {DateFrom, from} | {DateTo, to}
                 DateFrom = DateTo = calendar:datetime()

              Displays the reports that match the provided filters.

              When a filter includes the no atom, it excludes the reports that match that filter.

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

              If the filter has the form {Key, RegExp, re}, the report must contain an element with key equal to
              Key and the value must match the regular expression RegExp.

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

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

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

              To filter only by dates, specify the empty list as the Filters parameter.

              For details about parameter RegExp, see rb:grep/1.

              For details about data type mp(), see re:mp().

              For details about data type datetime(), see calendar:datetime().

       grep(RegExp)

              Types:

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

              All  reports  matching  the  regular  expression  RegExp  are  displayed. RegExp can be any of the
              following:

                * 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

              For a definition of valid regular expressions and options, see the re  module  in  STDLIB  and  in
              particular function re:run/3.

              For details about data type mp(), see re:mp().

       h()
       help()

              Displays online 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

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

              If no Type is specified, 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 functions list/0 or list/1, but the result is printed to a log file, if set; otherwise  to
              standard_io.

              If no Type is specified, all reports are listed.

       rescan()
       rescan(Options)

              Types:

                 Options = [opt()]

              Rescans the report directory. Options is the same as for function start/1.

       show()
       show(Report)

              Types:

                 Report = integer() | type()

              If  argument  type  is  specified,  all  loaded  reports of this type are displayed. If an integer
              argument is specified, the report with this reference number  is  displayed.  If  no  argument  is
              specified, all reports are displayed.

       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 = integer() | all
                 DirString = string()
                 ReportType = type() | [type()] | all
                 Bool = boolean()

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

              Options:

                {start_log, FileName}:
                  Starts logging to file, registered  name,  or  io_device.  All  reports  are  printed  to  the
                  specified  destination.  Default  is  standard_io.  Option  {start_log, standard_error} is not
                  allowed and will be replaced by default standard_io.

                {max, MaxNoOfReports}:
                  Controls how many reports rb_server is to read at startup.  This  option  is  useful,  as  the
                  directory  can  contain  a  large  amount  of  reports.  If  this  option  is  specified,  the
                  MaxNoOfReports latest reports are read. Default is all.

                {report_dir, DirString}:
                  Defines the directory where the  error  log  files  are  located.  Default  is  the  directory
                  specified by application environment variable error_logger_mf_dir, see sasl(7).

                {type, ReportType}:
                  Controls what kind of reports rb_server is to read at startup. ReportType is a supported type,
                  all, or a list of supported types. Default is all.

                {abort_on_error, Bool}:
                  Specifies  if  logging  is  to be ended if rb encounters an unprintable report. (You can get a
                  report with an incorrect form if function error_logger, error_msg, or info_msg has been called
                  with an invalid format string)

                  * If Bool is true, rb stops logging (and prints an error message to stdout) if it encounters a
                    badly formatted report. If logging to file is enabled, an error message is appended  to  the
                    log file as well.

                  * If  Bool  is  false  (the default value), rb prints an error message to stdout for every bad
                    report it encounters, but the logging process is never  ended.  All  printable  reports  are
                    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 rb_server.

       stop_log()

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

Ericsson AB                                         sasl 4.2                                            rb(3erl)