File: logger.go

package info (click to toggle)
golang-coreos-log 0.0~git20140508-5
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 128 kB
  • sloc: makefile: 3
file content (94 lines) | stat: -rw-r--r-- 2,779 bytes parent folder | download | duplicates (3)
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
package log
// Copyright 2013, CoreOS, Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// author: David Fisher <ddf1991@gmail.com>
// based on previous package by: Cong Ding <dinggnu@gmail.com>

import (
	"errors"
	"os"
	"path"
	"path/filepath"
	"runtime"
	"time"
)

func executable() (string, error) {
	switch runtime.GOOS {
	case "linux":
		return os.Readlink("/proc/self/exe")
	case "netbsd":
		return os.Readlink("/proc/curproc/exe")
	case "openbsd":
		return os.Readlink("/proc/curproc/file")
	}
	return "", errors.New("ExecPath not implemented for " + runtime.GOOS)
}

// Executable returns an absolute path that can be used to
// re-invoke the current program.
// It may not be valid after the current program exits.
func Executable() (string, error) {
	p, err := executable()
	return filepath.Clean(p), err
}

// Logger is user-immutable immutable struct which can log to several outputs
type Logger struct {
	sinks   []Sink // the sinks this logger will log to
	verbose bool   // gather expensive logging data?
	prefix  string // static field available to all log sinks under this logger

	created    time.Time // time when this logger was created
	seq        uint64    // sequential number of log message, starting at 1
	executable string    // executable name
}

// New creates a new Logger which logs to all the supplied sinks.  The prefix
// argument is passed to all loggers under the field "prefix" with every log
// message.  If verbose is true, more expensive runtime fields will be computed
// and passed to loggers.  These fields are funcname, lineno, pathname, and
// filename.
func New(prefix string, verbose bool, sinks ...Sink) *Logger {
	return &Logger{
		sinks:   sinks,
		verbose: verbose,
		prefix:  prefix,

		created:    time.Now(),
		seq:        0,
		executable: getExecutableName(),
	}
}

func getExecutableName() string {
	executablePath, err := Executable()
	if err != nil {
		return "(UNKNOWN)"
	} else {
		return path.Base(executablePath)
	}
}

// NewSimple(sinks...) is equivalent to New("", false, sinks...)
func NewSimple(sinks ...Sink) *Logger {
	return New("", false, sinks...)
}

var defaultLogger *Logger

func init() {
	defaultLogger = NewSimple(CombinedSink(os.Stdout, BasicFormat, BasicFields))
}