Module Async_unix.Log

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 ... end
module Message : sig ... end
module Rotation : sig ... end
module Output : sig ... end
module Blocking : sig ... end
type t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
module type Global_intf = sig ... end

An interface for singleton logs.

module Make_global : functor () -> Global_intf

This functor can be called to generate "singleton" logging modules.

Programs 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.t

Sets the log level via a flag, if provided.

val set_level : t -> Level.t -> unit

Messages sent at a level less than the current level will not be output.

val level : t -> Level.t

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.

val set_output : t -> Output.t list -> unit

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 get_output : t -> Output.t list
val set_on_error : t -> [ `Raise | `Call of Core.Error.t -> unit ] -> unit

If `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.t

Any call that writes to a log after close is called will raise.

val is_closed : t -> bool

Returns true if close has been called.

val flushed : t -> unit Async_kernel.Deferred.t

Returns 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.t

Informs 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 ] -> t

Creates 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 -> 'a
val debug : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> ('a, unit, string, unit) Core.format4 -> 'a
val info : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> ('a, unit, string, unit) Core.format4 -> 'a
val error : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> ('a, unit, string, unit) Core.format4 -> 'a
val printf : ?⁠level:Level.t -> ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> ('a, unit, string, unit) Core.format4 -> 'a

Generalized printf-style logging.

val raw_s : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> Core.Sexp.t -> unit
val info_s : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> Core.Sexp.t -> unit
val error_s : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> Core.Sexp.t -> unit
val debug_s : ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> Core.Sexp.t -> unit
val sexp : ?⁠level:Level.t -> ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> Core.Sexp.t -> unit

Generalized sexp-style logging.

val string : ?⁠level:Level.t -> ?⁠time:Core.Time.t -> ?⁠tags:(string * string) list -> t -> string -> unit

Log a string directly.

val message : t -> Message.t -> unit

Log a pre-created message.

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.t

surround 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 -> 'a
val would_log : t -> Level.t option -> bool

would_log returns true if a message at the given log level would be logged if sent immediately.

module Reader : sig ... end
module For_testing : sig ... end