1 // Copyright (c) 2016 Uber Technologies, Inc.
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE.
20 21 package zap
22 23 import (
24 "sync/atomic"
25 26 "go.uber.org/zap/internal"
27 "go.uber.org/zap/zapcore"
28 )
29 30 const (
31 // DebugLevel logs are typically voluminous, and are usually disabled in
32 // production.
33 DebugLevel = zapcore.DebugLevel
34 // InfoLevel is the default logging priority.
35 InfoLevel = zapcore.InfoLevel
36 // WarnLevel logs are more important than Info, but don't need individual
37 // human review.
38 WarnLevel = zapcore.WarnLevel
39 // ErrorLevel logs are high-priority. If an application is running smoothly,
40 // it shouldn't generate any error-level logs.
41 ErrorLevel = zapcore.ErrorLevel
42 // DPanicLevel logs are particularly important errors. In development the
43 // logger panics after writing the message.
44 DPanicLevel = zapcore.DPanicLevel
45 // PanicLevel logs a message, then panics.
46 PanicLevel = zapcore.PanicLevel
47 // FatalLevel logs a message, then calls os.Exit(1).
48 FatalLevel = zapcore.FatalLevel
49 )
50 51 // LevelEnablerFunc is a convenient way to implement zapcore.LevelEnabler with
52 // an anonymous function.
53 //
54 // It's particularly useful when splitting log output between different
55 // outputs (e.g., standard error and standard out). For sample code, see the
56 // package-level AdvancedConfiguration example.
57 type LevelEnablerFunc func(zapcore.Level) bool
58 59 // Enabled calls the wrapped function.
60 func (f LevelEnablerFunc) Enabled(lvl zapcore.Level) bool { return f(lvl) }
61 62 // An AtomicLevel is an atomically changeable, dynamic logging level. It lets
63 // you safely change the log level of a tree of loggers (the root logger and
64 // any children created by adding context) at runtime.
65 //
66 // The AtomicLevel itself is an http.Handler that serves a JSON endpoint to
67 // alter its level.
68 //
69 // AtomicLevels must be created with the NewAtomicLevel constructor to allocate
70 // their internal atomic pointer.
71 type AtomicLevel struct {
72 l *atomic.Int32
73 }
74 75 var _ internal.LeveledEnabler = AtomicLevel{}
76 77 // NewAtomicLevel creates an AtomicLevel with InfoLevel and above logging
78 // enabled.
79 func NewAtomicLevel() AtomicLevel {
80 lvl := AtomicLevel{l: new(atomic.Int32)}
81 lvl.l.Store(int32(InfoLevel))
82 return lvl
83 }
84 85 // NewAtomicLevelAt is a convenience function that creates an AtomicLevel
86 // and then calls SetLevel with the given level.
87 func NewAtomicLevelAt(l zapcore.Level) AtomicLevel {
88 a := NewAtomicLevel()
89 a.SetLevel(l)
90 return a
91 }
92 93 // ParseAtomicLevel parses an AtomicLevel based on a lowercase or all-caps ASCII
94 // representation of the log level. If the provided ASCII representation is
95 // invalid an error is returned.
96 //
97 // This is particularly useful when dealing with text input to configure log
98 // levels.
99 func ParseAtomicLevel(text string) (AtomicLevel, error) {
100 a := NewAtomicLevel()
101 l, err := zapcore.ParseLevel(text)
102 if err != nil {
103 return a, err
104 }
105 106 a.SetLevel(l)
107 return a, nil
108 }
109 110 // Enabled implements the zapcore.LevelEnabler interface, which allows the
111 // AtomicLevel to be used in place of traditional static levels.
112 func (lvl AtomicLevel) Enabled(l zapcore.Level) bool {
113 return lvl.Level().Enabled(l)
114 }
115 116 // Level returns the minimum enabled log level.
117 func (lvl AtomicLevel) Level() zapcore.Level {
118 return zapcore.Level(int8(lvl.l.Load()))
119 }
120 121 // SetLevel alters the logging level.
122 func (lvl AtomicLevel) SetLevel(l zapcore.Level) {
123 lvl.l.Store(int32(l))
124 }
125 126 // String returns the string representation of the underlying Level.
127 func (lvl AtomicLevel) String() string {
128 return lvl.Level().String()
129 }
130 131 // UnmarshalText unmarshals the text to an AtomicLevel. It uses the same text
132 // representations as the static zapcore.Levels ("debug", "info", "warn",
133 // "error", "dpanic", "panic", and "fatal").
134 func (lvl *AtomicLevel) UnmarshalText(text []byte) error {
135 if lvl.l == nil {
136 lvl.l = &atomic.Int32{}
137 }
138 139 var l zapcore.Level
140 if err := l.UnmarshalText(text); err != nil {
141 return err
142 }
143 144 lvl.SetLevel(l)
145 return nil
146 }
147 148 // MarshalText marshals the AtomicLevel to a byte slice. It uses the same
149 // text representation as the static zapcore.Levels ("debug", "info", "warn",
150 // "error", "dpanic", "panic", and "fatal").
151 func (lvl AtomicLevel) MarshalText() (text []byte, err error) {
152 return lvl.Level().MarshalText()
153 }
154