package async_log

You can search for identifiers within the package.

in-package search v0.2.0

package async_log

async_log
- Library async_log
  - Async_log
    
    For_testing
    
    Blocking
    
    Output
    
    Level
    
    Message
    
    T1
    
    Stable
    
    V2
    
    For_testing
    
    Message_event
    
    Output
    
    Format
    
    Stable
    
    V1
    
    Private
    
    For_testing
    
    Reader
    
    Expert
    
    Rotation
    
    Naming_scheme
    
    Rotation_id
    
    S
    
    Global
    
    S
    
    Make
    
    For_testing
    
    Ppx_log_syntax
    
    Ppx_log_syntax
    
    Global
    
    No_global
    
    Ppx_log_syntax
    
    Global
- Library async_log.kernel
  - Async_log_kernel
    
    Global
    
    S
    
    For_testing
    
    Make
    
    For_testing
    
    For_testing
    
    Level
    
    Stable
    
    V1
    
    Log
    
    For_testing
    
    Message
    
    T1
    
    Stable
    
    T1
    
    V2
    
    For_testing
    
    Message_event
    
    Unstable
    
    Private
    
    Output
    
    Format
    
    Stable
    
    V1
    
    Private
    
    For_testing
    
    Ppx_log_syntax
    
    Ppx_log_syntax
    
    Global
    
    No_global
    
    Ppx_log_syntax
    
    Global
    
    For_testing
    
    Mutable_outputs
- Sources
  - async_log
    
    assign_top_level_logs.ml
    
    async_log.ml
    
    async_log__.ml
    
    blocking.ml
    
    import.ml
    
    import_stable.ml
    
    log.ml
    
    message.ml
    
    message_reader.ml
    
    output.ml
    
    rotation.ml
    
    rotation_id.ml
    
    rotation_id_intf.ml
  - async_log.kernel
    
    async_log_kernel.ml
    
    async_log_kernel__.ml
    
    buffered_output.ml
    
    global.ml
    
    global_intf.ml
    
    import.ml
    
    level.ml
    
    live_entry_registry.ml
    
    log.ml
    
    message.ml
    
    message_event.ml
    
    mutable_outputs.ml
    
    on_error.ml
    
    output.ml
    
    output_format.ml
    
    ppx_log_syntax.ml
    
    raw_log.ml
    
    sexp_or_string.ml
    
    versioned.ml
    
    versioned_intf.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Async_log`Source

include module type of Async_log_kernel.Log

Sourcetype t = Async_log_kernel.Log.t

Sourceval sexp_of_t : t -> Sexplib0.Sexp.t

Sourceval set_level_via_param : t -> unit Core.Command.Param.t

Sets the log level via a flag, if provided.

Sourceval set_level : t -> Async_log_kernel.Level.t -> unit

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

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

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

Sourceval get_output : t -> Async_log_kernel.Output.t list

Sourceval get_time_source : t -> Async_kernel.Synchronous_time_source.t

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

Sourceval set_time_source : t -> Async_kernel.Synchronous_time_source.t -> unit

Source

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

Changes the transform function within log. This allows you to *synchronously* change things about the message at the time that they were written.

The transform function *will not* be called if the initial message is of a level that would not currently be logged.

The transform function *will* be called if even if there are no log outputs.

Source

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

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

Sourceval set_on_error : t -> [ `Raise | `Call of Core.Error.t -> unit ] -> unit

Sourceval close : t -> unit Async_kernel.Deferred.t

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

Sourceval is_closed : t -> bool

Returns true if close has been called.

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

Source

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:Async_kernel.Synchronous_time_source.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.

Sourceval create_null : unit -> t

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

Sourceval copy : t -> t

Creates a copy of a log, which has the same settings and logs to the same outputs.

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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.

Source

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

Log a string directly.

Source

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

Sourceval message : t -> Async_log_kernel.Message.t -> unit

Log a pre-created message.

Sourceval message_event : t -> Async_log_kernel.Message_event.t -> unit

Source

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.

Source

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

Sourceval would_log : t -> Async_log_kernel.Level.t option -> bool

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.

Sourcemodule For_testing = Async_log_kernel.Log.For_testing

Sourcemodule Blocking : sig ... end

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

Sourcemodule Level = Async_log_kernel.Level

Sourcemodule Message : sig ... end

Sourcemodule Message_event = Async_log_kernel.Message_event

Sourcemodule Output : sig ... end

Sourcemodule Reader : sig ... end

Sourcemodule Rotation : sig ... end

Sourcemodule Rotation_id : sig ... end

Sourcemodule Global : module type of Async_log_kernel.Global

Sourcemodule Ppx_log_syntax : module type of Async_log_kernel.Ppx_log_syntax

package async_log

Module Async_logSource

Module `Async_log`Source