Module B0_std.Log

Program log.

Support for program logging. Not to be used by build logic.

The module is modelled after Logs logging, see this quick introduction. It can be made to log on a Logs source, see here.

FIXME This should maybe moved to B0_ui. Make the doc self contained (cf. references to Logs).

Reporting levels

type level =
| Quiet
| App
| Error
| Warning
| Info
| Debug

The type for reporting levels. They are meant to be used as follows:

  • Quiet doesn't report anything.
  • App can be used for the standard output or console of an application. Using this instead of stdout directly allows the output to be silenced by Quiet which may be desirable, or not.
  • Error is an error condition that prevents the program from running.
  • Warning is a suspicious condition that does not prevent the program from running normally but may eventually lead to an error condition.
  • Info is a condition that allows the program user to get a better understanding of what the program is doing.
  • Debug is a condition that allows the program developer to get a better understanding of what the program is doing.
val level : unit -> level

level () is the current reporting level.

val set_level : level -> unit

set_level l sets the current reporting level to l.

val pp_level : level Fmt.t

pp_level ppf l prints and unspecified representation of l on ppf.

val level_to_string : level -> string

level_to_string l converts l to a string representation.

val level_of_string : string -> (level, string) Stdlib.Pervasives.result

level_of_string s parses a level from s according to the representation of level_to_string.

Log functions

type ('a, 'b) msgf = (?⁠header:string -> ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a) -> 'b

The type for client specified message formatting functions. See Logs.msgf.

type 'a log = ('a, unit) msgf -> unit

The type for log functions. See Logs.log.

val msg : level -> 'a log

See Logs.msg.

val quiet : 'a log

quiet is msg Quiet.

val app : 'a log

app is msg App.

val err : 'a log

err is msg Error.

val warn : 'a log

warn is msg Warning.

val info : 'a log

info is msg Info.

val debug : 'a log

debug is msg Debug.

val kmsg : (unit -> 'b) -> level -> ('a, 'b) msgf -> 'b

kmsg k level m logs m with level level and continues with k.

Logging result value Error messages

val if_error : ?⁠level:level -> ?⁠header:string -> use:'a -> ('a, string) Stdlib.Pervasives.result -> 'a

if_error ~level ~use v r is:

  • v, if r is Ok v
  • use and e is logged with level (defaults to Error), if r is Error e.
val warn_if_error : ?⁠header:string -> use:'a -> ('a, string) Stdlib.Pervasives.result -> 'a

warn_if_error is if_error ~level:Warning.

val if_error_pp : ?⁠level:level -> ?⁠header:string -> 'b Fmt.t -> use:'a -> ('a, 'b) Stdlib.Pervasives.result -> 'a

if_error_pp ~level pp ~use r is

  • v, if r is Ok v.
  • use and e is logged with level (defaults to Error) using pp, if r is Error e.

Logging timings

val time : ?⁠level:level -> ('a -> (('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 -> 'b) -> 'a) -> (unit -> 'a) -> 'a

time ~level m f logs m with level level (defaults to Info) and the time f () took as the log header.

Log monitoring

val err_count : unit -> int

err_count () is the number of messages logged with level Error.

val warn_count : unit -> int

warn_count () is the number of messages logged with level Warning.

Logger

The following function allows to change the logging backend. Note that in this case monitoring and level functions are no longer relevant.

type kmsg = {
kmsg : a b. (unit -> 'b) -> level -> ('a, 'b) msgf -> 'b;
}

The type for the basic logging function. The function is never invoked with a level of Quiet.

val kmsg_nop : kmsg

nop_kmsg is a logger that does nothing.

val kmsg_default : kmsg

kmsg_default is the default logger that logs messages on Fmt.stderr except for Log.level.App level which logs on Fmt.stdout.

val set_kmsg : kmsg -> unit

set_kmsg kmsg sets the logging function to kmsg.