sig
  module Level :
    sig
      type t = [ `Debug | `Error | `Info ]
      val of_string : string -> t
      val to_string : t -> string
      val t_of_sexp : Sexplib.Sexp.t -> t
      val t_of_sexp__ : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Message :
    sig
      type t = Log.Message.t
      val time : t -> Core.Std.Time.t
      val message : t -> string
      val level : t -> Level.t option
      val tags : t -> (string * string) list
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read_ml.reader
      val bin_read_t_ : t Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_read_t__ : (int -> t) Core.Std.Bin_prot.Unsafe_read_c.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write_ml.writer
      val bin_write_t_ : t Core.Std.Bin_prot.Unsafe_write_c.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module Rotation :
    sig
      type t =
        Log.Rotation.t = {
        messages : int option;
        size : Core.Std.Byte_units.t option;
        time : (Core.Std.Time.Ofday.t * Core.Std.Zone.t) option;
        keep :
          [ `All | `At_least of int | `Newer_than of Core.Std.Time.Span.t ];
      }
    end
  module Output :
    sig
      type machine_readable_format = [ `Bin_prot | `Sexp ]
      type format = [ `Bin_prot | `Sexp | `Text ]
      type t = Log.Output.t
      val create :
        (Message.t Core.Std.Queue.t -> unit Import.Deferred.t) -> t
      val screen : t
      val writer : format -> Import.Writer.t -> t
      val file : format -> filename:string -> t
      val rotating_file :
        format -> basename:string -> Rotation.t -> t Import.Deferred.t
    end
  module type Global_intf =
    sig
      val set_level : Level.t -> unit
      val set_output : Output.t list -> unit
      val raw :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val info :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val error :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val debug :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val printf :
        ?tags:(string * string) list ->
        ?level:Level.t -> ('a, unit, string, unit) format4 -> 'a
      val sexp :
        ?tags:(string * string) list ->
        ?level:Level.t -> ('a -> Core.Std.Sexp.t) -> 'a -> unit
      val of_lazy :
        ?tags:(string * string) list ->
        ?level:Level.t -> string Core.Std.Lazy.t -> unit
      val message : Message.t -> unit
      val flushed : unit -> unit Import.Deferred.t
    end
  module Blocking :
    sig
      module Output :
        sig
          type t = Log.Blocking.Output.t
          val screen : t
          val create : (Message.t -> unit) -> t
        end
      val set_level : Level.t -> unit
      val set_output : Output.t -> unit
      val raw :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val info :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val error :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val debug :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
    end
  module Make_global :
    functor (Empty : sig  end) ->
      sig
        val set_level : Level.t -> unit
        val set_output : Output.t list -> unit
        val raw :
          ?tags:(string * string) list ->
          ('a, unit, string, unit) format4 -> 'a
        val info :
          ?tags:(string * string) list ->
          ('a, unit, string, unit) format4 -> 'a
        val error :
          ?tags:(string * string) list ->
          ('a, unit, string, unit) format4 -> 'a
        val debug :
          ?tags:(string * string) list ->
          ('a, unit, string, unit) format4 -> 'a
        val printf :
          ?tags:(string * string) list ->
          ?level:Level.t -> ('a, unit, string, unit) format4 -> 'a
        val sexp :
          ?tags:(string * string) list ->
          ?level:Level.t -> ('a -> Core.Std.Sexp.t) -> 'a -> unit
        val of_lazy :
          ?tags:(string * string) list ->
          ?level:Level.t -> string Core.Std.Lazy.t -> unit
        val message : Message.t -> unit
        val flushed : unit -> unit Import.Deferred.t
      end
  module Global :
    sig
      val set_level : Level.t -> unit
      val set_output : Output.t list -> unit
      val raw :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val info :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val error :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val debug :
        ?tags:(string * string) list ->
        ('a, unit, string, unit) format4 -> 'a
      val printf :
        ?tags:(string * string) list ->
        ?level:Level.t -> ('a, unit, string, unit) format4 -> 'a
      val sexp :
        ?tags:(string * string) list ->
        ?level:Level.t -> ('a -> Core.Std.Sexp.t) -> 'a -> unit
      val of_lazy :
        ?tags:(string * string) list ->
        ?level:Level.t -> string Core.Std.Lazy.t -> unit
      val message : Message.t -> unit
      val flushed : unit -> unit Import.Deferred.t
    end
  type t = Log.t
  val set_level : t -> Level.t -> unit
  val set_output : t -> Output.t list -> unit
  val close : t -> unit
  val flushed : t -> unit Import.Deferred.t
  val create : level:Level.t -> output:Output.t list -> t
  val raw :
    ?tags:(string * string) list ->
    t -> ('a, unit, string, unit) format4 -> 'a
  val info :
    ?tags:(string * string) list ->
    t -> ('a, unit, string, unit) format4 -> 'a
  val error :
    ?tags:(string * string) list ->
    t -> ('a, unit, string, unit) format4 -> 'a
  val debug :
    ?tags:(string * string) list ->
    t -> ('a, unit, string, unit) format4 -> 'a
  val printf :
    ?tags:(string * string) list ->
    ?level:Level.t -> t -> ('a, unit, string, unit) format4 -> 'a
  val sexp :
    ?tags:(string * string) list ->
    ?level:Level.t -> t -> 'a -> ('a -> Core.Std.Sexp.t) -> unit
  val of_lazy :
    ?tags:(string * string) list ->
    ?level:Level.t -> t -> string Core.Std.Lazy.t -> unit
  val message : t -> Message.t -> unit
  module Reader :
    sig
      val pipe :
        [< Output.machine_readable_format ] ->
        string -> Message.t Import.Pipe.Reader.t
    end
  val ounit_tests : unit -> OUnit.test
end