package easy_logging

  1. Overview
  2. Docs

Source file easy_logging.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


(* Type for log levels *)
type log_level = Easy_logging_types.level
               [@@deriving show { with_path = false }]
module type HandlersT = Easy_logging_types.HandlersT
                     
                      
(** Makes a logging module from a Handlers module *)
module MakeLogging (H : HandlersT) =
  struct

    (** logger class *)
    class logger
            (name: string)
            (levelo: log_level option)
            (handlers_desc : H.desc list)  =
    object(self)

      (** Handlers associated to the logger *)
      val mutable handlers = List.map H.make handlers_desc

      (** optional level of the logger *)
      val mutable levelo = levelo

      (** Name of the logger *)
      val name = name

 
      method private log_msg tags msg_level msg =
        match levelo with
        | None ->()
        | Some level ->
           if msg_level >= level
           then
             begin
               let item : H.log_item= {
                   level = msg_level;
                   logger_name = name;
                   msg = msg;
                   tags=tags} in 
               List.iter (fun handler ->
                   H.apply handler item)
                 handlers
             end
           else
             ()                           
          
      method private log_msg_lazy tags (msg_level : log_level) msg =
        match levelo with
        | None ->()
        | Some level ->
           if msg_level >= level
           then
             begin
               let item : H.log_item = {
                   level = msg_level;
                   logger_name = name;
                   msg = Lazy.force msg;
                   tags= tags} in 
               List.iter (fun handler ->
                   H.apply handler item)
                 handlers
             end
           else
             ()

      method add_handler h = handlers <- h::handlers
      method set_level new_levelo =
        levelo <- new_levelo
        
      method flash ?tags:(tags=[]) = self#log_msg tags Flash
      method error ?tags:(tags=[]) = self#log_msg tags Error
      method warning ?tags:(tags=[]) = self#log_msg tags Warning
      method info ?tags:(tags=[]) =  self#log_msg tags Info
      method debug ?tags:(tags=[]) = self#log_msg tags Debug
                   
      method lflash ?tags:(tags=[]) = self#log_msg_lazy tags Flash
      method lerror ?tags:(tags=[]) = self#log_msg_lazy tags Error
      method lwarning ?tags:(tags=[]) = self#log_msg_lazy tags Warning
      method linfo ?tags:(tags=[]) =  self#log_msg_lazy tags Info
      method ldebug ?tags:(tags=[]) = self#log_msg_lazy tags Debug
    end


  
    let _loggers : (string, logger) Hashtbl.t =  Hashtbl.create 10
                                               
    let set_level p lvlo =
      Hashtbl.iter
        (fun n l  ->
          
          if String.sub n 0 (String.length p) = p
          then
            l#set_level lvlo;)
        _loggers
      
    let get_logger name =
      if Hashtbl.mem _loggers name
      then
        Hashtbl.find _loggers name
      else
        let l = new logger name None [] in
        Hashtbl.add _loggers name l;
        l
        
    let make_logger name lvl hdescs  =
      let l = new logger name lvl hdescs in
      Hashtbl.add _loggers name l;
      l
      
      
    let dummy = make_logger "dummy" None []
    
                    
  end

module Default_handlers = Default_handlers
                
(** Instantiation of [MakeLogging] over [Default_handlers] *)
module Logging = MakeLogging(Default_handlers)