A library for general logging.
Although this module is fully Async-safe it exposes almost no Deferreds. This is partially a design choice to minimize the impact of logging in code, and partially the result of organic design (i.e., older versions of this interface did the same thing).
A (limited) Blocking module is supplied to accommodate the portion of a program that runs outside of Async.
module Level : sig ... endmodule Message : sig ... endmodule Rotation : sig ... endmodule Output : sig ... endmodule Blocking : sig ... endAsync programs often have a non-Async portion that runs before the scheduler begins to capture command line options, do setup, read configs, etc. This module provides limited global logging functions to be used during that period. Calling these functions after the scheduler has started will raise an exception. They otherwise behave similarly to the logging functions in the Async world.
include sig ... endval sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.tmodule type Global_intf = sig ... endAn interface for singleton logs.
module Make_global () : Global_intfThis functor can be called to generate "singleton" logging modules.
module Global : Global_intfPrograms that want simplistic single-channel logging can open this module. It provides a global logging facility to a single output type at a single level. More nuanced logging can be had by using the functions that operate on a distinct Log.t type.
val set_level_via_param : t -> unit Core.Command.Param.tSets the log level via a flag, if provided.
Messages sent at a level less than the current level will not be output.
Returns the last level passed to set_level, which will be the log level checked as a threshold against the level of the next message sent.
Changes the output type of the log, which can be useful when daemonizing. The new output type will be applied to all subsequent messages.
val set_on_error : t -> [ `Raise | `Call of Core.Error.t -> unit ] -> unitIf `Raise is given, then background errors raised by logging will be raised to the monitor that was in scope when create was called. Errors can be redirected anywhere by providing `Call f.
val close : t -> unit Async_kernel.Deferred.tAny call that writes to a log after close is called will raise.
val is_closed : t -> boolReturns true if close has been called.
val flushed : t -> unit Async_kernel.Deferred.tReturns a Deferred.t that is fulfilled when the last message delivered to t before the call to flushed is out the door.
val rotate : t -> unit Async_kernel.Deferred.tInforms the current Outputs to rotate if possible.
val create :
level:Level.t ->
output:Output.t list ->
on_error:[ `Raise | `Call of Core.Error.t -> unit ] ->
tCreates a new log. See set_level, set_on_error and set_output for more.
val raw :
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
('a, unit, string, unit) Core.format4 ->
'aPrintf-like logging for raw (no level) messages. Raw messages are still output with a timestamp.
val debug :
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
('a, unit, string, unit) Core.format4 ->
'aPrintf-like logging at the `Debug log level.
val info :
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
('a, unit, string, unit) Core.format4 ->
'aPrintf-like logging at the `Info log level.
val error :
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
('a, unit, string, unit) Core.format4 ->
'aPrintf-like logging at the `Error log level.
val printf :
?level:Level.t ->
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
('a, unit, string, unit) Core.format4 ->
'aGeneralized printf-style logging.
val sexp :
?level:Level.t ->
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
Core.Sexp.t ->
unitLog sexps directly.
val string :
?level:Level.t ->
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
string ->
unitLogging of string values.
val surround_s :
?level:Level.t ->
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
Core.Sexp.t ->
(unit -> 'a Async_kernel.Deferred.t) ->
'a Async_kernel.Deferred.tsurround t message f logs message and a UUID once before calling f and again after f returns or raises. If f raises, the second message will include the exception, and surround itself will re-raise the exception tagged with message. As usual, the logging happens only if level exceeds the minimum level of t.
val surroundf :
?level:Level.t ->
?time:Core.Time.t ->
?tags:(string * string) list ->
t ->
('a,
unit,
string,
(unit -> 'b Async_kernel.Deferred.t) ->
'b Async_kernel.Deferred.t)
Core.format4 ->
'awould_log returns true if a message at the given log level would be logged if sent immediately.
module Reader : sig ... end