├── .gitignore ├── CODEOWNERS ├── LICENSE ├── README.md ├── go.mod ├── level.go ├── level_benchmark_test.go └── level_test.go /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | -------------------------------------------------------------------------------- /CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @hashicorp/vault-ecosystem 2 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2013 HashiCorp, Inc. 2 | 3 | Mozilla Public License, version 2.0 4 | 5 | 1. Definitions 6 | 7 | 1.1. “Contributor” 8 | 9 | means each individual or legal entity that creates, contributes to the 10 | creation of, or owns Covered Software. 11 | 12 | 1.2. “Contributor Version” 13 | 14 | means the combination of the Contributions of others (if any) used by a 15 | Contributor and that particular Contributor’s Contribution. 16 | 17 | 1.3. “Contribution” 18 | 19 | means Covered Software of a particular Contributor. 20 | 21 | 1.4. “Covered Software” 22 | 23 | means Source Code Form to which the initial Contributor has attached the 24 | notice in Exhibit A, the Executable Form of such Source Code Form, and 25 | Modifications of such Source Code Form, in each case including portions 26 | thereof. 27 | 28 | 1.5. “Incompatible With Secondary Licenses” 29 | means 30 | 31 | a. that the initial Contributor has attached the notice described in 32 | Exhibit B to the Covered Software; or 33 | 34 | b. that the Covered Software was made available under the terms of version 35 | 1.1 or earlier of the License, but not also under the terms of a 36 | Secondary License. 37 | 38 | 1.6. “Executable Form” 39 | 40 | means any form of the work other than Source Code Form. 41 | 42 | 1.7. “Larger Work” 43 | 44 | means a work that combines Covered Software with other material, in a separate 45 | file or files, that is not Covered Software. 46 | 47 | 1.8. “License” 48 | 49 | means this document. 50 | 51 | 1.9. “Licensable” 52 | 53 | means having the right to grant, to the maximum extent possible, whether at the 54 | time of the initial grant or subsequently, any and all of the rights conveyed by 55 | this License. 56 | 57 | 1.10. “Modifications” 58 | 59 | means any of the following: 60 | 61 | a. any file in Source Code Form that results from an addition to, deletion 62 | from, or modification of the contents of Covered Software; or 63 | 64 | b. any new file in Source Code Form that contains any Covered Software. 65 | 66 | 1.11. “Patent Claims” of a Contributor 67 | 68 | means any patent claim(s), including without limitation, method, process, 69 | and apparatus claims, in any patent Licensable by such Contributor that 70 | would be infringed, but for the grant of the License, by the making, 71 | using, selling, offering for sale, having made, import, or transfer of 72 | either its Contributions or its Contributor Version. 73 | 74 | 1.12. “Secondary License” 75 | 76 | means either the GNU General Public License, Version 2.0, the GNU Lesser 77 | General Public License, Version 2.1, the GNU Affero General Public 78 | License, Version 3.0, or any later versions of those licenses. 79 | 80 | 1.13. “Source Code Form” 81 | 82 | means the form of the work preferred for making modifications. 83 | 84 | 1.14. “You” (or “Your”) 85 | 86 | means an individual or a legal entity exercising rights under this 87 | License. For legal entities, “You” includes any entity that controls, is 88 | controlled by, or is under common control with You. For purposes of this 89 | definition, “control” means (a) the power, direct or indirect, to cause 90 | the direction or management of such entity, whether by contract or 91 | otherwise, or (b) ownership of more than fifty percent (50%) of the 92 | outstanding shares or beneficial ownership of such entity. 93 | 94 | 95 | 2. License Grants and Conditions 96 | 97 | 2.1. Grants 98 | 99 | Each Contributor hereby grants You a world-wide, royalty-free, 100 | non-exclusive license: 101 | 102 | a. under intellectual property rights (other than patent or trademark) 103 | Licensable by such Contributor to use, reproduce, make available, 104 | modify, display, perform, distribute, and otherwise exploit its 105 | Contributions, either on an unmodified basis, with Modifications, or as 106 | part of a Larger Work; and 107 | 108 | b. under Patent Claims of such Contributor to make, use, sell, offer for 109 | sale, have made, import, and otherwise transfer either its Contributions 110 | or its Contributor Version. 111 | 112 | 2.2. Effective Date 113 | 114 | The licenses granted in Section 2.1 with respect to any Contribution become 115 | effective for each Contribution on the date the Contributor first distributes 116 | such Contribution. 117 | 118 | 2.3. Limitations on Grant Scope 119 | 120 | The licenses granted in this Section 2 are the only rights granted under this 121 | License. No additional rights or licenses will be implied from the distribution 122 | or licensing of Covered Software under this License. Notwithstanding Section 123 | 2.1(b) above, no patent license is granted by a Contributor: 124 | 125 | a. for any code that a Contributor has removed from Covered Software; or 126 | 127 | b. for infringements caused by: (i) Your and any other third party’s 128 | modifications of Covered Software, or (ii) the combination of its 129 | Contributions with other software (except as part of its Contributor 130 | Version); or 131 | 132 | c. under Patent Claims infringed by Covered Software in the absence of its 133 | Contributions. 134 | 135 | This License does not grant any rights in the trademarks, service marks, or 136 | logos of any Contributor (except as may be necessary to comply with the 137 | notice requirements in Section 3.4). 138 | 139 | 2.4. Subsequent Licenses 140 | 141 | No Contributor makes additional grants as a result of Your choice to 142 | distribute the Covered Software under a subsequent version of this License 143 | (see Section 10.2) or under the terms of a Secondary License (if permitted 144 | under the terms of Section 3.3). 145 | 146 | 2.5. Representation 147 | 148 | Each Contributor represents that the Contributor believes its Contributions 149 | are its original creation(s) or it has sufficient rights to grant the 150 | rights to its Contributions conveyed by this License. 151 | 152 | 2.6. Fair Use 153 | 154 | This License is not intended to limit any rights You have under applicable 155 | copyright doctrines of fair use, fair dealing, or other equivalents. 156 | 157 | 2.7. Conditions 158 | 159 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in 160 | Section 2.1. 161 | 162 | 163 | 3. Responsibilities 164 | 165 | 3.1. Distribution of Source Form 166 | 167 | All distribution of Covered Software in Source Code Form, including any 168 | Modifications that You create or to which You contribute, must be under the 169 | terms of this License. You must inform recipients that the Source Code Form 170 | of the Covered Software is governed by the terms of this License, and how 171 | they can obtain a copy of this License. You may not attempt to alter or 172 | restrict the recipients’ rights in the Source Code Form. 173 | 174 | 3.2. Distribution of Executable Form 175 | 176 | If You distribute Covered Software in Executable Form then: 177 | 178 | a. such Covered Software must also be made available in Source Code Form, 179 | as described in Section 3.1, and You must inform recipients of the 180 | Executable Form how they can obtain a copy of such Source Code Form by 181 | reasonable means in a timely manner, at a charge no more than the cost 182 | of distribution to the recipient; and 183 | 184 | b. You may distribute such Executable Form under the terms of this License, 185 | or sublicense it under different terms, provided that the license for 186 | the Executable Form does not attempt to limit or alter the recipients’ 187 | rights in the Source Code Form under this License. 188 | 189 | 3.3. Distribution of a Larger Work 190 | 191 | You may create and distribute a Larger Work under terms of Your choice, 192 | provided that You also comply with the requirements of this License for the 193 | Covered Software. If the Larger Work is a combination of Covered Software 194 | with a work governed by one or more Secondary Licenses, and the Covered 195 | Software is not Incompatible With Secondary Licenses, this License permits 196 | You to additionally distribute such Covered Software under the terms of 197 | such Secondary License(s), so that the recipient of the Larger Work may, at 198 | their option, further distribute the Covered Software under the terms of 199 | either this License or such Secondary License(s). 200 | 201 | 3.4. Notices 202 | 203 | You may not remove or alter the substance of any license notices (including 204 | copyright notices, patent notices, disclaimers of warranty, or limitations 205 | of liability) contained within the Source Code Form of the Covered 206 | Software, except that You may alter any license notices to the extent 207 | required to remedy known factual inaccuracies. 208 | 209 | 3.5. Application of Additional Terms 210 | 211 | You may choose to offer, and to charge a fee for, warranty, support, 212 | indemnity or liability obligations to one or more recipients of Covered 213 | Software. However, You may do so only on Your own behalf, and not on behalf 214 | of any Contributor. You must make it absolutely clear that any such 215 | warranty, support, indemnity, or liability obligation is offered by You 216 | alone, and You hereby agree to indemnify every Contributor for any 217 | liability incurred by such Contributor as a result of warranty, support, 218 | indemnity or liability terms You offer. You may include additional 219 | disclaimers of warranty and limitations of liability specific to any 220 | jurisdiction. 221 | 222 | 4. Inability to Comply Due to Statute or Regulation 223 | 224 | If it is impossible for You to comply with any of the terms of this License 225 | with respect to some or all of the Covered Software due to statute, judicial 226 | order, or regulation then You must: (a) comply with the terms of this License 227 | to the maximum extent possible; and (b) describe the limitations and the code 228 | they affect. Such description must be placed in a text file included with all 229 | distributions of the Covered Software under this License. Except to the 230 | extent prohibited by statute or regulation, such description must be 231 | sufficiently detailed for a recipient of ordinary skill to be able to 232 | understand it. 233 | 234 | 5. Termination 235 | 236 | 5.1. The rights granted under this License will terminate automatically if You 237 | fail to comply with any of its terms. However, if You become compliant, 238 | then the rights granted under this License from a particular Contributor 239 | are reinstated (a) provisionally, unless and until such Contributor 240 | explicitly and finally terminates Your grants, and (b) on an ongoing basis, 241 | if such Contributor fails to notify You of the non-compliance by some 242 | reasonable means prior to 60 days after You have come back into compliance. 243 | Moreover, Your grants from a particular Contributor are reinstated on an 244 | ongoing basis if such Contributor notifies You of the non-compliance by 245 | some reasonable means, this is the first time You have received notice of 246 | non-compliance with this License from such Contributor, and You become 247 | compliant prior to 30 days after Your receipt of the notice. 248 | 249 | 5.2. If You initiate litigation against any entity by asserting a patent 250 | infringement claim (excluding declaratory judgment actions, counter-claims, 251 | and cross-claims) alleging that a Contributor Version directly or 252 | indirectly infringes any patent, then the rights granted to You by any and 253 | all Contributors for the Covered Software under Section 2.1 of this License 254 | shall terminate. 255 | 256 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user 257 | license agreements (excluding distributors and resellers) which have been 258 | validly granted by You or Your distributors under this License prior to 259 | termination shall survive termination. 260 | 261 | 6. Disclaimer of Warranty 262 | 263 | Covered Software is provided under this License on an “as is” basis, without 264 | warranty of any kind, either expressed, implied, or statutory, including, 265 | without limitation, warranties that the Covered Software is free of defects, 266 | merchantable, fit for a particular purpose or non-infringing. The entire 267 | risk as to the quality and performance of the Covered Software is with You. 268 | Should any Covered Software prove defective in any respect, You (not any 269 | Contributor) assume the cost of any necessary servicing, repair, or 270 | correction. This disclaimer of warranty constitutes an essential part of this 271 | License. No use of any Covered Software is authorized under this License 272 | except under this disclaimer. 273 | 274 | 7. Limitation of Liability 275 | 276 | Under no circumstances and under no legal theory, whether tort (including 277 | negligence), contract, or otherwise, shall any Contributor, or anyone who 278 | distributes Covered Software as permitted above, be liable to You for any 279 | direct, indirect, special, incidental, or consequential damages of any 280 | character including, without limitation, damages for lost profits, loss of 281 | goodwill, work stoppage, computer failure or malfunction, or any and all 282 | other commercial damages or losses, even if such party shall have been 283 | informed of the possibility of such damages. This limitation of liability 284 | shall not apply to liability for death or personal injury resulting from such 285 | party’s negligence to the extent applicable law prohibits such limitation. 286 | Some jurisdictions do not allow the exclusion or limitation of incidental or 287 | consequential damages, so this exclusion and limitation may not apply to You. 288 | 289 | 8. Litigation 290 | 291 | Any litigation relating to this License may be brought only in the courts of 292 | a jurisdiction where the defendant maintains its principal place of business 293 | and such litigation shall be governed by laws of that jurisdiction, without 294 | reference to its conflict-of-law provisions. Nothing in this Section shall 295 | prevent a party’s ability to bring cross-claims or counter-claims. 296 | 297 | 9. Miscellaneous 298 | 299 | This License represents the complete agreement concerning the subject matter 300 | hereof. If any provision of this License is held to be unenforceable, such 301 | provision shall be reformed only to the extent necessary to make it 302 | enforceable. Any law or regulation which provides that the language of a 303 | contract shall be construed against the drafter shall not be used to construe 304 | this License against a Contributor. 305 | 306 | 307 | 10. Versions of the License 308 | 309 | 10.1. New Versions 310 | 311 | Mozilla Foundation is the license steward. Except as provided in Section 312 | 10.3, no one other than the license steward has the right to modify or 313 | publish new versions of this License. Each version will be given a 314 | distinguishing version number. 315 | 316 | 10.2. Effect of New Versions 317 | 318 | You may distribute the Covered Software under the terms of the version of 319 | the License under which You originally received the Covered Software, or 320 | under the terms of any subsequent version published by the license 321 | steward. 322 | 323 | 10.3. Modified Versions 324 | 325 | If you create software not governed by this License, and you want to 326 | create a new license for such software, you may create and use a modified 327 | version of this License if you rename the license and remove any 328 | references to the name of the license steward (except to note that such 329 | modified license differs from this License). 330 | 331 | 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses 332 | If You choose to distribute Source Code Form that is Incompatible With 333 | Secondary Licenses under the terms of this version of the License, the 334 | notice described in Exhibit B of this License must be attached. 335 | 336 | Exhibit A - Source Code Form License Notice 337 | 338 | This Source Code Form is subject to the 339 | terms of the Mozilla Public License, v. 340 | 2.0. If a copy of the MPL was not 341 | distributed with this file, You can 342 | obtain one at 343 | http://mozilla.org/MPL/2.0/. 344 | 345 | If it is not possible or desirable to put the notice in a particular file, then 346 | You may include the notice in a location (such as a LICENSE file in a relevant 347 | directory) where a recipient would be likely to look for such a notice. 348 | 349 | You may add additional accurate notices of copyright ownership. 350 | 351 | Exhibit B - “Incompatible With Secondary Licenses” Notice 352 | 353 | This Source Code Form is “Incompatible 354 | With Secondary Licenses”, as defined by 355 | the Mozilla Public License, v. 2.0. 356 | 357 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # logutils 2 | 3 | logutils is a Go package that augments the standard library "log" package 4 | to make logging a bit more modern, without fragmenting the Go ecosystem 5 | with new logging packages. 6 | 7 | ## The simplest thing that could possibly work 8 | 9 | Presumably your application already uses the default `log` package. To switch, you'll want your code to look like the following: 10 | 11 | ```go 12 | package main 13 | 14 | import ( 15 | "log" 16 | "os" 17 | 18 | "github.com/hashicorp/logutils" 19 | ) 20 | 21 | func main() { 22 | filter := &logutils.LevelFilter{ 23 | Levels: []logutils.LogLevel{"DEBUG", "WARN", "ERROR"}, 24 | MinLevel: logutils.LogLevel("WARN"), 25 | Writer: os.Stderr, 26 | } 27 | log.SetOutput(filter) 28 | 29 | log.Print("[DEBUG] Debugging") // this will not print 30 | log.Print("[WARN] Warning") // this will 31 | log.Print("[ERROR] Erring") // and so will this 32 | log.Print("Message I haven't updated") // and so will this 33 | } 34 | ``` 35 | 36 | This logs to standard error exactly like go's standard logger. Any log messages you haven't converted to have a level will continue to print as before. 37 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/hashicorp/logutils 2 | -------------------------------------------------------------------------------- /level.go: -------------------------------------------------------------------------------- 1 | // Package logutils augments the standard log package with levels. 2 | package logutils 3 | 4 | import ( 5 | "bytes" 6 | "io" 7 | "sync" 8 | ) 9 | 10 | type LogLevel string 11 | 12 | // LevelFilter is an io.Writer that can be used with a logger that 13 | // will filter out log messages that aren't at least a certain level. 14 | // 15 | // Once the filter is in use somewhere, it is not safe to modify 16 | // the structure. 17 | type LevelFilter struct { 18 | // Levels is the list of log levels, in increasing order of 19 | // severity. Example might be: {"DEBUG", "WARN", "ERROR"}. 20 | Levels []LogLevel 21 | 22 | // MinLevel is the minimum level allowed through 23 | MinLevel LogLevel 24 | 25 | // The underlying io.Writer where log messages that pass the filter 26 | // will be set. 27 | Writer io.Writer 28 | 29 | badLevels map[LogLevel]struct{} 30 | once sync.Once 31 | } 32 | 33 | // Check will check a given line if it would be included in the level 34 | // filter. 35 | func (f *LevelFilter) Check(line []byte) bool { 36 | f.once.Do(f.init) 37 | 38 | // Check for a log level 39 | var level LogLevel 40 | x := bytes.IndexByte(line, '[') 41 | if x >= 0 { 42 | y := bytes.IndexByte(line[x:], ']') 43 | if y >= 0 { 44 | level = LogLevel(line[x+1 : x+y]) 45 | } 46 | } 47 | 48 | _, ok := f.badLevels[level] 49 | return !ok 50 | } 51 | 52 | func (f *LevelFilter) Write(p []byte) (n int, err error) { 53 | // Note in general that io.Writer can receive any byte sequence 54 | // to write, but the "log" package always guarantees that we only 55 | // get a single line. We use that as a slight optimization within 56 | // this method, assuming we're dealing with a single, complete line 57 | // of log data. 58 | 59 | if !f.Check(p) { 60 | return len(p), nil 61 | } 62 | 63 | return f.Writer.Write(p) 64 | } 65 | 66 | // SetMinLevel is used to update the minimum log level 67 | func (f *LevelFilter) SetMinLevel(min LogLevel) { 68 | f.MinLevel = min 69 | f.init() 70 | } 71 | 72 | func (f *LevelFilter) init() { 73 | badLevels := make(map[LogLevel]struct{}) 74 | for _, level := range f.Levels { 75 | if level == f.MinLevel { 76 | break 77 | } 78 | badLevels[level] = struct{}{} 79 | } 80 | f.badLevels = badLevels 81 | } 82 | -------------------------------------------------------------------------------- /level_benchmark_test.go: -------------------------------------------------------------------------------- 1 | package logutils 2 | 3 | import ( 4 | "io/ioutil" 5 | "testing" 6 | ) 7 | 8 | var messages [][]byte 9 | 10 | func init() { 11 | messages = [][]byte{ 12 | []byte("[TRACE] foo"), 13 | []byte("[DEBUG] foo"), 14 | []byte("[INFO] foo"), 15 | []byte("[WARN] foo"), 16 | []byte("[ERROR] foo"), 17 | } 18 | } 19 | 20 | func BenchmarkDiscard(b *testing.B) { 21 | for i := 0; i < b.N; i++ { 22 | ioutil.Discard.Write(messages[i%len(messages)]) 23 | } 24 | } 25 | 26 | func BenchmarkLevelFilter(b *testing.B) { 27 | filter := &LevelFilter{ 28 | Levels: []LogLevel{"TRACE", "DEBUG", "INFO", "WARN", "ERROR"}, 29 | MinLevel: "WARN", 30 | Writer: ioutil.Discard, 31 | } 32 | 33 | b.ResetTimer() 34 | for i := 0; i < b.N; i++ { 35 | filter.Write(messages[i%len(messages)]) 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /level_test.go: -------------------------------------------------------------------------------- 1 | package logutils 2 | 3 | import ( 4 | "bytes" 5 | "io" 6 | "log" 7 | "testing" 8 | ) 9 | 10 | func TestLevelFilter_impl(t *testing.T) { 11 | var _ io.Writer = new(LevelFilter) 12 | } 13 | 14 | func TestLevelFilter(t *testing.T) { 15 | buf := new(bytes.Buffer) 16 | filter := &LevelFilter{ 17 | Levels: []LogLevel{"DEBUG", "WARN", "ERROR"}, 18 | MinLevel: "WARN", 19 | Writer: buf, 20 | } 21 | 22 | logger := log.New(filter, "", 0) 23 | logger.Print("[WARN] foo") 24 | logger.Println("[ERROR] bar") 25 | logger.Println("[DEBUG] baz") 26 | logger.Println("[WARN] buzz") 27 | 28 | result := buf.String() 29 | expected := "[WARN] foo\n[ERROR] bar\n[WARN] buzz\n" 30 | if result != expected { 31 | t.Fatalf("bad: %#v", result) 32 | } 33 | } 34 | 35 | func TestLevelFilterCheck(t *testing.T) { 36 | filter := &LevelFilter{ 37 | Levels: []LogLevel{"DEBUG", "WARN", "ERROR"}, 38 | MinLevel: "WARN", 39 | Writer: nil, 40 | } 41 | 42 | testCases := []struct { 43 | line string 44 | check bool 45 | }{ 46 | {"[WARN] foo\n", true}, 47 | {"[ERROR] bar\n", true}, 48 | {"[DEBUG] baz\n", false}, 49 | {"[WARN] buzz\n", true}, 50 | } 51 | 52 | for _, testCase := range testCases { 53 | result := filter.Check([]byte(testCase.line)) 54 | if result != testCase.check { 55 | t.Errorf("Fail: %s", testCase.line) 56 | } 57 | } 58 | } 59 | 60 | func TestLevelFilter_SetMinLevel(t *testing.T) { 61 | filter := &LevelFilter{ 62 | Levels: []LogLevel{"DEBUG", "WARN", "ERROR"}, 63 | MinLevel: "ERROR", 64 | Writer: nil, 65 | } 66 | 67 | testCases := []struct { 68 | line string 69 | checkBefore bool 70 | checkAfter bool 71 | }{ 72 | {"[WARN] foo\n", false, true}, 73 | {"[ERROR] bar\n", true, true}, 74 | {"[DEBUG] baz\n", false, false}, 75 | {"[WARN] buzz\n", false, true}, 76 | } 77 | 78 | for _, testCase := range testCases { 79 | result := filter.Check([]byte(testCase.line)) 80 | if result != testCase.checkBefore { 81 | t.Errorf("Fail: %s", testCase.line) 82 | } 83 | } 84 | 85 | // Update the minimum level to WARN 86 | filter.SetMinLevel("WARN") 87 | 88 | for _, testCase := range testCases { 89 | result := filter.Check([]byte(testCase.line)) 90 | if result != testCase.checkAfter { 91 | t.Errorf("Fail: %s", testCase.line) 92 | } 93 | } 94 | } 95 | --------------------------------------------------------------------------------