Log_extended (p.async.v0.18~preview.130.106+341.doc.async.log_extended.Log

include module type of struct include Async.Log end

include module type of struct include Async_log end

include module type of Async_log_kernel.Log

type t : value mod contended portable = Async_log_kernel__.Log.t

val sexp_of_t : t -> Sexplib0.Sexp.t

val set_level_via_param : 
  ?default:Async_log_kernel__.Level.t ->
  t ->
  unit Core.Command.Param.t

Sets the log level via a flag, if provided.

If default is not provided, the existing log level will be unchanged if the flag is not provided.

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

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

val level : t -> Async_log_kernel__.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 -> Async_log_kernel__.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 -> Async_log_kernel__.Output.t list

val get_time_source : t -> Async_kernel.Synchronous_time_source.t

Changes the time source of the log, which controls the default timestamp on messages.

val set_time_source : 
  t ->
  [> Core.read ] Async_kernel.Synchronous_time_source.T1.t ->
  unit

module Transform = Async.Log.Transform

A transform is a function to be called on each log invocation *synchronously* that can be used to change things about the message at the time that they were written.

val has_transform : t -> bool

val clear_transforms : t -> unit

val set_transform : 
  t ->
  (Async_log_kernel__.Message_event.t ->
    Async_log_kernel__.Message_event.t option)
    option ->
  unit

deprecated [since 2024-10] Use [Log.Transform.add] instead

val get_transform : 
  t ->
  (Async_log_kernel__.Message_event.t ->
    Async_log_kernel__.Message_event.t option)
    option

deprecated [since 2024-10] Getting the transform is not supported but transforms may cleared with [Log.clear_transforms] or added to with [Log.Transform.add]

val add_tags : t -> tags:(string * string) list -> unit

One common transformation on message events is tagging every remaining message with a list of fixed tags.

add_tags t ~tags is shorthand for Transform.prepend t (Message_event.add_tags ~tags). (prepend in this case means these tags are added before any other transformation is applied, which we believe is more often wanted, e.g. if a later transform flattens the message and tags into a single rendered string.)

This is not idempotent - if you add the same tags twice, they'll be included twice in the resultant message.

val add_tags' : t -> tags:(string * string) list -> Transform.t

Like add_tags except that a Transform.t is returned which one can call Transform.remove_exn with.

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

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 once the last message delivered to t before the call to flushed has been written and flushed by t's outputs.

Logs written via portable functions, such as Log.Portable.info, may not have been delivered to t yet when flushed is called. flushed only waits for messages that have already been delivered to t.

val create : 
  level:Async_log_kernel__.Level.t ->
  output:Async_log_kernel__.Output.t list ->
  on_error:[ `Raise | `Call of Core.Error.t -> unit ] ->
  ?time_source:[> Core.read ] Async_kernel.Synchronous_time_source.T1.t ->
  ?transform:
    (Async_log_kernel__.Message_event.t -> Async_log_kernel__.Message_event.t) ->
  unit ->
  t

Creates a new log. See set_level, set_on_error, set_output, set_time_source, and set_transform for more.

val create_null : unit -> t

Log that drops messages sent to it, as if it wrote to /dev/null

val copy : 
  ?level:Async_log_kernel__.Level.t ->
  ?on_error:[ `Call of Core.Error.t -> unit | `Raise ] ->
  ?output:Async_log_kernel__.Output.t list ->
  ?extra_tags:(string * string) list ->
  t ->
  t

Make a copy of this log, with potentially some settings changed, or potentially extra tags added to each line.

module Control_event = Async.Log.Control_event

val control_events : t -> (Control_event.t @ local -> unit) Bus.Read_only.t

A bus that may be subscribed to to get control events which happen to this t.

(In at least one case, this was used to watch for level changes and change a different Log.t's level in a different process in response.)

If you subscribe to this bus and your callback raises, the error will be ignored. It is recommended that you subscribe with Bus.Subscribe so that you may pass ~on_callback_raise there.

Printf-like logging for messages at each log level or raw (no level) messages. Raw messages still include a timestamp.

val raw : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  ('a, unit, string, unit) Core.format4 ->
  'a

val debug : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  ('a, unit, string, unit) Core.format4 ->
  'a

val info : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  ('a, unit, string, unit) Core.format4 ->
  'a

val warn : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  ('a, unit, string, unit) Core.format4 ->
  'a

val error : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  ('a, unit, string, unit) Core.format4 ->
  'a

val printf : 
  ?level:Async_log_kernel__.Level.t ->
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  ('a, unit, string, unit) Core.format4 ->
  'a

Generalized printf-style logging.

Sexp logging for messages at each log level or raw (no level) messages. Raw messages still include a timestamp

val raw_s : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Core.Sexp.t ->
  unit

val info_s : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Core.Sexp.t ->
  unit

val warn_s : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Core.Sexp.t ->
  unit

val error_s : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Core.Sexp.t ->
  unit

val debug_s : 
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Core.Sexp.t ->
  unit

val sexp : 
  ?level:Async_log_kernel__.Level.t ->
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Core.Sexp.t ->
  unit

Generalized sexp-style logging.

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

Log a string directly.

val structured_message : 
  ?level:Async_log_kernel__.Level.t ->
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Ppx_log_types.Message_data.t ->
  Ppx_log_types.Message_source.t ->
  unit

val enqueue_structured_message : 
  ?level:Async_log_kernel__.Level.t ->
  ?time:Core.Time_float.t ->
  ?tags:(string * string) list ->
  t ->
  Ppx_log_types.Message_data.t ->
  Ppx_log_types.Message_source.t ->
  unit @@ portable

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

Log a pre-created message.

val message_event : t -> Async_log_kernel__.Message_event.t -> unit

val surround_s : 
  ?on_subsequent_errors:[ `Call of exn -> unit | `Log | `Raise ] ->
  ?level:Async_log_kernel__.Level.t ->
  ?time:Core.Time_float.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. on_subsequent_errors is passed to the internal monitor as rest argument. As usual, the logging happens only if level exceeds the minimum level of t.

val surroundf : 
  ?on_subsequent_errors:[ `Call of exn -> unit | `Log | `Raise ] ->
  ?level:Async_log_kernel__.Level.t ->
  ?time:Core.Time_float.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 -> Async_log_kernel__.Level.t option -> bool @@ portable

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

This will return false if there are no outputs for the log, unless there is a transform set.

module For_testing = Async.Log.For_testing

Sourcemodule Private = Async.Log.Private

Sourcemodule Blocking = Async.Log.Blocking

module Level = Async.Log.Level

Sourcemodule Message = Async.Log.Message

module Message_event = Async.Log.Message_event

Sourcemodule Output = Async.Log.Output

Sourcemodule Reader = Async.Log.Reader

Sourcemodule Rotation = Async.Log.Rotation

Sourcemodule Rotation_id = Async.Log.Rotation_id

module Global = Async.Log.Global

module Ppx_log_syntax = Async.Log.Ppx_log_syntax

Sourcemodule Console : sig ... end

Sourcemodule Syslog : sig ... end

Sourcemodule Command : sig ... end