package async_extended

You can search for identifiers within the package.

in-package search v0.2.0

async_extended
- Async_extended
  - Any_error
    
    Applicative_infix
  - Async_cbreak
  - Async_color_print
  - Async_heap
  - Async_mutex
  - Coalesced_throttle
  - Cpu_load
    
    Stats
  - Csv
  - Deferred_cache
  - Deferred_list
  - Delimited
  - Embedded_script
  - Enforcer
  - Extended_log
    
    Console
    
    Blocking
    
    Syslog
    
    Blocking
  - Fd_leak_check
  - File_updates
    
    Update
  - Find
  - Generator
  - Inotify
  - Interactive_edit
  - Keyed_sequencer
  - Ltl
    
    Make
    
    Assignment
    
    Expression
    
    Applicative_infix
    
    Args
    
    Field
    
    O
    
    State
    
    Variable
    
    State
  - Mailbox
    
    Filter
  - Pipe_iterator
  - Pipe_zipper
  - Priority_queue
  - Process
    
    Output
  - Reader_ext
  - Resource
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    Memo
    
    Key
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Provide_bin_io
    
    X
    
    Provide_of_sexp
    
    X
    
    Table
    
    Provide_bin_io
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Monad_infix
    
    Raw
    
    Handle
  - Rpc_proxy
    
    Environment
  - Run_in_fork
  - Semaphore
  - Shell
  - Signal
  - Simple_tcp_proxy
  - Sound
  - Std
    
    Log
    
    Reader
  - Synccast
  - Udp
  - Validate_command
    
    S
  - Watcher

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Async.Log end

module Level = Async.Log.Level

module Message = Async.Log.Message

module Rotation = Async.Log.Rotation

module Output = Async.Log.Output

module Blocking = Async.Log.Blocking

type t = Async_unix.Log.t

include sig ... end

val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t

module type Global_intf = Async.Log.Global_intf

An interface for singleton logs.

module Make_global = Async.Log.Make_global

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

module Global = Async.Log.Global

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

Printf-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 ->
  'a

Printf-like logging at the `Debug log level.

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

Printf-like logging at the `Info log level.

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

Printf-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 ->
  'a

Generalized printf-style logging.

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

Log sexps directly.

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

Logging of string values.

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

Log a preexisting 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 = Async.Log.Reader

include module type of struct include Extended_log end

module Console = Extended_log.Console

module Syslog = Extended_log.Syslog