Type of log levels. A level determines the importance of a message

Type of a logger. A logger is responsible for dispatching messages and storing them somewhere.

Each logging message has a section. Sections can be used to structure your logs. For example you can choose different loggers according to the section.

Each section carries a level, and messages with a lower log level than than the section level will be dropped.

Section levels are initialised using the contents of the LWT_LOG environment variable, which must contain one or more rules of the form pattern -> level separated by ";". Where pattern is a string that may contain *.

For example, if LWT_LOG contains:

  access -> warning;
  foo[*] -> error

then the level of the section "access" is Warning and the level of any section matching "foo[*]" is Error.

If the pattern is omited in a rule then the pattern "*" is used instead, so LWT_LOG may just contain "debug" for instance.

By default, the following rule apply : "* -> notice"

Reset the rules set when parsing the LWT_LOG environment variable using this string.

• parameter fail_on_error

  defines if the function will raise Failure if it encounters a malformed rule

• raises Failure

  if an invalid rule is found and fail_on_error is true

load_rules parses the rules string and validates the rules before loading them. If fail_on_error is true, invalid rules will cause this function to raise Failure and leave existing rules unchanged. If fail_on_error is false (this is the default), it tries to load as many rules as possible and ignore invalid ones. If the rules string itself cannot be parsed, existing rules are always left unchanged.

Example:

Lwt_log_core.load_rules ~fail_on_error:true "* -> nosuchlevel" (* Raises Failure *)
Lwt_log_core.load_rules "* -> info"

add_rule pattern level adds a rule for sections logging levels. The rule is added before all other rules. It takes effect immediately and affects all sections for which the level has not been set explicitly with Section.set_level. pattern may contains *. For example:

  Lwt_log_core.add_rule "lwt*" Lwt_log_core.Info

append_rule pattern level adds the given rule after all other rules. For example to set the default fallback rule:

  Lwt_log_core.append_rule "*" Lwt_log_core.Info

removes all rules.

Sections

A template is for generating log messages.

It is a string which may contains variables of the form $(var), where var is one of:

• message which will be replaced by the message emited
• level which will be replaced by a string representation of the level
• section which will be replaced by the name of the message's section
• loc-file which will be replaced by the file name of the calling logging function
• loc-line which will be replaced by the line number of the calling logging function
• loc-column which will be replaced by the column number of the calling logging function

For example:

• "$(name): $(message)"
• "$(name): $(loc-file): $(loc-line): $(loc-column): $(message)"

render ~buffer ~template ~section ~level ~message instantiate all variables of template, and store the result in buffer. The location is obtained from threads local storage.

The key for storing current location.

Exception raised when trying to use a closed logger

make ~output ~close creates a new logger.

• parameter output

  is used to write logs. It is a function which receive a section, a level and a list lines that must be logged together.

• parameter close

  is used to close the logger.

Close the given logger

The default logger. It is used as default when no one is specified. If Lwt_core is linked (in the package lwt.unix) the default logger sends all messages to standard error. Otherwise the default logger is null.

broadcast loggers is a logger which send messages to all the given loggers.

Note: closing a broadcast logger does not close its components.

dispatch f is a logger which dispatch logging instructions to different logger according to their level and/or section.

Here is an example:

  let access_logger = Lwt_log.file "access.log"
  and error_logger = Lwt_log.file "error.log" in

  Lwt_log_core.dispatch
    (fun section level ->
      match Lwt_log_core.Section.name section, level with
        | "access", _ -> access_logger
        | _, Lwt_log_core.Error -> error_logger)

Logger which drops everything