(* $Id: netlog.mli 1692 2012-02-05 18:44:00Z gerd $ *)

(** Basic logging facility

    The purpose of this module is to define a mutable logging function
    which ensures to be always pointing to a valid logging implementation.
    By default, the function prints the messages to stderr, prepended
    by a timestamp. In Netplex context, the implementation is changed so
    that the Netplex logger is used instead (see {!Netplex_log}), and
    the [log] and [logf] functions below have the same effect as
    the counterparts in {!Netplex_cenv} with the same name.
 *)

type level =
    [ `Emerg | `Alert | `Crit | `Err | `Warning | `Notice | `Info | `Debug ]
  (** The log levels (syslog-like) *)

type logger =
    level -> string -> unit
  (** A logging function takes a level, and the message *)

val channel_logger : out_channel -> level -> logger
  (** [channel_logger ch lev]: Prints all messages with a level of [lev]
      and higher to the channel [ch]. The output buffer is flushed after
      each message,
   *)

val current_logger : logger ref
  (** The variable containing the current logger function.
      Defaults to [channel_logger stderr `Debug] at program startup.
      Assign something else to this variable in order to change the
      log destination or the log level.

      Note that the function {!Netplex_main.run} modifies [current_logger]
      so log messages are forwarded to the Netplex logger. It is then the
      Netplex framework that determines log destination and level.
   *)

val log : level -> string -> unit
  (** Writes a log message *)

val logf : level -> ('a, unit, string, unit) format4 -> 'a
  (** Writes a log message like [printf] *)

val level_weight : level -> int
  (** A number correspondig to the level *)

val level_of_string : string -> level
val string_of_level : level -> string
  (** Convert level names to strings and vice versa *)

val level_names : string array
  (** The level names indexed by weight *)

type format = [ `Std | `ISO ]

val format_timestamp : format -> int -> (float * int) -> string
  (** [format_timestamp fmt digits (seconds,nanos)]: Formats the timestamp
      [(seconds,nanos)] and returns the string. Pass in [digits] the number
      of digits for fractional seconds.

      - [`Std]: This is the "%c" format of [Netdate]
      - [`ISO]: ISO-8601 format
   *)

val current_formatter : ((float * int) -> string) ref
  (** The current timestamp formatter

      Example: Change the format of timestamps to ISO with a precision
      of milliseconds:
      {[
        Netlog.current_formatter := Netlog.format_timestamp `ISO 3
      ]}
   *)

module Debug : sig
  (** Controlling messages for debugging Ocamlnet *)
  
  (** Many Ocamlnet modules can emit debug messages. For a module
      [M] (e.g. {!Rpc_client}) there is usually a sub module 
      [M.Debug] providing functions controlling the debug messages.
      These functions send the messages to this [Debug] module, and from here
      they are forwarded to {!Netlog.log} (with a level of [`Debug]).

      In this module everything is by default initialized to enable
      debug messages (i.e., [current_dlogger] is set to [fwd_dlogger],
      and this function sends the messages to [current_logger] where they are
      printed by [channel_logger stderr `Debug]). However, the debugged
      modules also need to be enabled individually. One can do this
      by setting the variable [M.Debug.enable] to [true], or by calling
      [enable_module] or [enable_all] (see below).

      Although this debug interface is mainly intended for Ocamlnet
      itself, it is not restricted to this. In order to use it for
      a user module, one has to register the boolean variable that
      controls whether debug messages are enabled (see [register_module]
      below). This should be done at module initialization time, and
      {b before} any thread is spawned.
   *)

  type dlogger =
      string -> string -> unit
    (** Debug logger: The first string is the module name, and the second 
        is the message
     *)

  val fwd_dlogger : dlogger
    (** The standard debug logger simply prepends the module name to the
        message (separated by ": "), and calls the current logger to
        print it
     *)

  val null_dlogger : dlogger
    (** The "logger" not printing anything *)

  val current_dlogger : dlogger ref
    (** The current debug logger. This is initialized to [fwd_dlogger] at
        program startup. Set this variable to [null_logger] to completely
        turn off debug logging of Ocamlnet.
     *)

  val log : string -> string -> unit
    (** Writes a log message *)

  val logf : string -> ('a, unit, string, unit) format4 -> 'a
    (** Writes a log message like [printf] *)

  val enable_module : string -> unit 
  val disable_module : string -> unit 
    (** Enable or disable the passed module [M]
        (e.g. [enable_module "Rpc_client"]). No exception is raised when
        the module name is invalid! Because of this, it is usually safer
        to change the variable [M.Debug.enable] directly (e.g.
        [Rpc_client.Debug.enable := true]).
     *)

  val enable_all : unit -> unit
    (** Enable all modules *)

  val disable_all : unit -> unit
    (** Disable all modules (the default) *)

  val names : unit -> string list
    (** Return the possible module names for [enable_module] and
        [disable_module]
     *)

  (** {2 For debugged Ocamlnet modules} *)

  val register_module : string -> bool ref -> unit
    (** Registers the [enable] variable of the named module *)

  val mk_dlog : string -> bool ref -> (string -> unit)
    (** [let dlog = mk_dlog "M" enable]: The conditional debug function *)

  val mk_dlogr : string -> bool ref -> ((unit -> string) -> unit)
    (** [let dlogr = mk_dlog "M" enable]: The conditional debug function *)

  (** {2 File descriptor tracking} *)

  (** [Netlog.Debug] also has a little hash table that maps file descriptors
      to an info record. This allows it to track file descriptors more
      easily, and to find file descriptor leaks, and "double close" bugs.
      All long-living descriptors managed by Ocamlnet should go into this
      table.
   *)

  type serial
    (** A serial number for the optional tracking of ownership *)

  val new_serial : unit -> serial
    (** Create new serial number *)

  val track_fd : 
        ?update:bool ->
        ?anchor:'a ->
        ?sn:serial ->
        owner:string ->
        descr:string ->
          Unix.file_descr -> unit
    (** [track_fd ~owner ~descr fd]: Enters the descriptor [fd] into the
        descriptor table. The [owner] string should be set to the module
        name. In [descr] one can give additional information, e.g. about
        the purpose, and details like the file name.

        It is not an error if there is also an entry for the descriptor
        [fd]. However, a warning is emitted (using the debug logger).
        By setting [update] to [true], this warning can be suppressed.
        The old entry is overwritten by the new one.

        The [anchor] can be an arbitrary boxed value. When the garbage
        collector calls the finaliser for [anchor] the descriptor is
        marked as dead, and will be tagged in the [fd_table] as such.

        By setting [sn] to a new serial number, the knowledge of this
        number is required to update the descriptor entry later,
        and to release the descriptor. If the entry is tried to be
        updated or released with the wrong serial number, a warning
        is emitted (to the debug logger).
     *)

  val release_fd : ?sn:serial -> ?force:bool -> Unix.file_descr -> unit
    (** Removes this descriptor from the descriptor table.

        It is not an error if the descriptor does not exist in the table.
        However, a warning is emitted (using the debug logger).

        [release_fd] must be invoked {b before} the descriptor is actually
        closed.

        [force]: If set, all warnings are suppressed
     *)

  val fd_string : ?owner:bool -> ?descr:bool -> Unix.file_descr -> string
    (** Return a string for generating debug messages. By default, the
        string only includes the numeric descriptor value.

        If [owner] is set to true, the string also includes the owner.
        If [descr] is set to true, the string also includes the description.

        The full version of this string looks like
        "76(Http_client - 87.65.213.67:80)". An untracked descriptor
        looks like "76(?)".
     *)

  val fd_table : unit -> string list
    (** Returns the table of descriptors as list of lines. 
        One can easily print them to stdout using
        [List.iter print_endline (fd_table())].
     *)

  val enable_fd_tracking : bool ref
    (** By setting to true, each [track_fd] and [release_fd] is 
        logged.
     *)
end

(**/**)

val ten_power : int -> int
