// GetLog gets log handler
func GetLog(level logging.Level) (l *logging.Logger) {
l = logging.MustGetLogger("ghostbox")
var customLogFormat = logging.MustStringFormatter(
"%{color}%{time:2006-01-02 15:04:05.000} %{level:.4s} %{shortfunc:16s} ▶ %{id:03x}%{color:reset} %{message}",
)
backend1 := logging.NewLogBackend(os.Stderr, "", 0)
backend2 := logging.NewLogBackend(os.Stdout, "", 0)
backend2Formatter := logging.NewBackendFormatter(backend2, customLogFormat)
backend1Leveled := logging.AddModuleLevel(backend1)
backend1Leveled.SetLevel(logging.ERROR, "")
backend2Leveled := logging.AddModuleLevel(backend2Formatter)
backend2Leveled.SetLevel(level, "") // 0=crit 1=err 2=warn 3=notice 4=info 5=debug
logging.SetBackend(backend1Leveled, backend2Leveled)
return
}
func setUpLogging(logLevel logging.Level) {
backend := logging.NewLogBackend(os.Stderr, "", 0)
backendFormatted := logging.NewBackendFormatter(backend, logFormat)
backendLeveled := logging.AddModuleLevel(backendFormatted)
backendLeveled.SetLevel(logLevel, "")
logging.SetBackend(backendLeveled)
}
func init() {
backend := logging.NewLogBackend(os.Stderr, "", 0)
logging.SetBackend(backend)
formatter := logging.MustStringFormatter("[%{time:15:04:05.000}] %{shortfile:18s}: %{color}[%{level:-5s}]%{color:reset} %{message}")
logging.SetFormatter(formatter)
logger = logging.MustGetLogger("orderer/kafka")
logging.SetLevel(logging.INFO, "") // Silence debug-level outputs when testing
}
func init() {
Logger = gologging.MustGetLogger("netspel")
format := gologging.MustStringFormatter("%{time:2006-01-02T15:04:05.000000Z} %{level} %{message}")
backend := gologging.NewLogBackend(os.Stdout, "", 0)
backendFormatter := gologging.NewBackendFormatter(backend, format)
LogLevel = gologging.AddModuleLevel(backendFormatter)
gologging.SetBackend(LogLevel)
}
func createLogger() {
f, err := openLogFile()
if err != nil {
return
}
be := gl.NewLogBackend(f, "", log.Ltime)
gl.SetBackend(be)
}
func init() {
var format = "%{color}%{time:15:04:05.000000} ▶ %{level:.4s} %{color:reset} %{message}"
logBackend := logging.NewLogBackend(os.Stderr, "", 0)
logging.SetFormatter(logging.MustStringFormatter(format))
logging.SetBackend(logBackend)
exp.Exp(metrics.DefaultRegistry)
}
func init() {
syncRoot = &sync.RWMutex{}
format := gologging.MustStringFormatter("%{color}%{time:15:04:05:000} %{shortfunc} > %{level:.4s} %{id:03x}%{color:reset} %{message}")
backend := gologging.NewLogBackend(os.Stdout, "", 0)
backendFormatter := gologging.NewBackendFormatter(backend, format)
backendLeveled = gologging.AddModuleLevel(backendFormatter)
backendLeveled.SetLevel(gologging.INFO, "")
gologging.SetBackend(backendLeveled)
}
func CreateLogger() *go_logging.Logger {
var logger = go_logging.MustGetLogger("vamp-gateway-agent")
var backend = go_logging.NewLogBackend(io.Writer(os.Stdout), "", 0)
backendFormatter := go_logging.NewBackendFormatter(backend, go_logging.MustStringFormatter(
"%{color}%{time:15:04:05.000} %{shortpkg:.4s} %{level:.4s} ==> %{message} %{color:reset}",
))
go_logging.SetBackend(backendFormatter)
return logger
}
func initLogging(level logging.Level, color bool) {
format := logging.MustStringFormatter(logFormat)
logging.SetFormatter(format)
for _, s := range logModules {
logging.SetLevel(level, s)
}
stdout := logging.NewLogBackend(os.Stdout, "", 0)
stdout.Color = color
logging.SetBackend(stdout)
}
// SetUpLogging sets up logging to output for the test framework
func SetUpLogging(output io.Writer) {
backend := logging.NewLogBackend(output, "", 0)
format := logging.MustStringFormatter(
"%{color}%{time:15:04:05.000}: %{module} %{level} %{color:reset} %{message}")
backendFormatter := logging.NewBackendFormatter(backend, format)
leveledBackendFormatter := logging.AddModuleLevel(backendFormatter)
leveledBackendFormatter.SetLevel(logging.INFO, "")
leveledBackendFormatter.SetLevel(logging.DEBUG, "extest")
logging.SetBackend(leveledBackendFormatter)
}
func setUpLogging() {
backend := logging.NewLogBackend(os.Stderr, "", 0)
format := logging.MustStringFormatter(
"%{color}%{time:15:04:05.000}: %{module} %{level} %{color:reset} %{message}")
backendFormatter := logging.NewBackendFormatter(backend, format)
leveledBackendFormatter := logging.AddModuleLevel(backendFormatter)
leveledBackendFormatter.SetLevel(logging.CRITICAL, "")
leveledBackendFormatter.SetLevel(logging.DEBUG, "extest")
logging.SetBackend(leveledBackendFormatter)
}
func getLogger(name string, logConfig LogConfig) *logger.Logger {
mainLogger.Info("Make logger of %s at file %s", name, logConfig.Filename)
log1 := logger.MustGetLogger(name)
var leveledBackend logger.LeveledBackend
f, err := logger.NewStringFormatter("%{shortfile} %{time:2006-01-02T15:04:05} %{level:.1s} %{id:04d} %{module} %{message}")
if err != nil {
mainLogger.Info("failed to set format: %s", err)
}
logger.SetFormatter(f)
if logConfig.Filename != "" {
logFileName := logConfig.Filename
logFile, err := os.OpenFile(logFileName, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
backend := logger.NewLogBackend(logFile, "", 0)
if err != nil {
mainLogger.Error("Failed to open log file - " + logFileName)
panic(err)
} else {
leveledBackend = logger.AddModuleLevel(backend)
}
} else {
backend := logger.NewLogBackend(os.Stdout, "", 0)
leveledBackend = logger.AddModuleLevel(backend)
}
switch logConfig.Level {
case "debug":
leveledBackend.SetLevel(logger.NOTICE, name)
case "error":
logger.SetLevel(logger.ERROR, name)
case "info":
logger.SetLevel(logger.INFO, name)
case "warn":
logger.SetLevel(logger.WARNING, name)
}
log1.SetBackend(leveledBackend)
return log1
}
func TestParmsLog(t *testing.T) {
Convey("Testing log()", t, func() {
tests := []struct {
dbug bool
name string
str string
verb bool
}{
{name: "Info", str: "This is a log.Info test", dbug: false, verb: true},
{name: "Debug", str: "This is a log.Debug test", dbug: true, verb: false},
{name: "Debug & Info", str: "This is both a log.Debug and log.Info test ", dbug: true, verb: true},
{name: "Both Debug or Info", str: "This is both a log.Debug and log.Info test and there should be output", dbug: true, verb: true},
{name: "Neither Debug or Info", str: "This is both a log.Debug and log.Info test and there shouldn't be any output", dbug: false, verb: false},
}
var (
scrFmt = logging.MustStringFormatter(`%{level:.4s}[%{id:03x}] ▶ %{message}`)
act = &bytes.Buffer{}
p = &Parms{Logger: logging.MustGetLogger("TestParmsLog"), Verb: true}
scr = logging.NewLogBackend(act, "", 0)
scrFmttr = logging.NewBackendFormatter(scr, scrFmt)
)
logging.SetBackend(scrFmttr)
for i, tt := range tests {
Convey("Testing "+tt.name, func() {
p.Dbug = tt.dbug
p.Verb = tt.verb
switch {
case tt.dbug:
p.debug(tt.str)
So(act.String(), ShouldEqual, fmt.Sprintf("DEBU[00%d] ▶ %v\n", i+1, tt.str))
case tt.verb:
p.log(tt.str)
So(act.String(), ShouldEqual, fmt.Sprintf("INFO[00%d] ▶ %v\n", i+1, tt.str))
case tt.dbug && tt.verb:
exp := fmt.Sprintf("DEBU[00%d] ▶ %v\n", i+1, tt.str)
exp += fmt.Sprintf("INFO[00%d] ▶ %v\n", i+1, tt.str)
p.debug(tt.str)
p.log(tt.str)
So(act.String(), ShouldEqual, exp)
default:
p.debug(tt.str)
p.log(tt.str)
So(act.String(), ShouldEqual, "")
}
act.Reset()
})
}
})
}
func newLog() (*logging.Logger, error) {
fdFmt := logging.MustStringFormatter(
`%{level:.4s}[%{id:03x}]%{time:2006-01-02 15:04:05.000} ▶ %{message}`,
)
scrFmt := logging.MustStringFormatter(
`%{color:bold}%{level:.4s}%{color:reset}[%{id:03x}]%{time:15:04:05.000} ▶ %{message}`,
)
fd, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
fdlog := logging.NewLogBackend(fd, "", 0)
fdFmttr := logging.NewBackendFormatter(fdlog, fdFmt)
scr := logging.NewLogBackend(os.Stderr, "", 0)
scrFmttr := logging.NewBackendFormatter(scr, scrFmt)
logging.SetBackend(fdFmttr, scrFmttr)
return logging.MustGetLogger(basename(os.Args[0])), err
}
func (lc *LoggerConfig) newGoLogger() *gol.Logger {
// Leveled formatted file backend.
backend := gol.AddModuleLevel(
gol.NewBackendFormatter(
gol.NewLogBackend(lc.Out, "", 0),
gol.MustStringFormatter(lc.Format)))
backend.SetLevel(lc.Level, "")
logger := gol.MustGetLogger("")
logger.SetBackend(backend)
return logger
}
func setLogger() *logging.Logger {
var log = logging.MustGetLogger("beano")
var format = logging.MustStringFormatter(
"%{color}%{time:15:04:05.000000} %{level:.5s} %{id:04d}%{color:reset} %{message}",
)
var logBackend = logging.NewLogBackend(os.Stdout, "", 0)
// bel := logging.AddModuleLevel(logBackend)
// bel.SetLevel(logging.ERROR, "")
var bf = logging.NewBackendFormatter(logBackend, format)
logging.SetBackend(bf)
return log
}
func Configure() {
golog.SetFormatter(golog.MustStringFormatter("[0x%{id:x}] [%{level}] [%{module}] %{message}"))
stdoutLogBackend := golog.NewLogBackend(os.Stdout, "", stdlog.LstdFlags|stdlog.Lshortfile)
stdoutLogBackend.Color = true
golog.SetLevel(defaultLevel, "")
// NOTE these file permissions are restricted by umask, so they probably won't work right.
err := os.MkdirAll("./log", 0775)
if err != nil {
panic(err)
}
logFile, err := os.OpenFile("./log/zendesk-livestats.log", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0664)
if err != nil {
panic(err)
}
fileLogBackend := golog.NewLogBackend(logFile, "", stdlog.LstdFlags|stdlog.Lshortfile)
fileLogBackend.Color = false
golog.SetBackend(stdoutLogBackend, fileLogBackend)
}
func init() {
Log = Logger{
log: gologging.MustGetLogger("default"),
}
format := gologging.MustStringFormatter(`%{shortfile} %{color} %{time:2006-01-02T15:04:05.000000Z} %{level:.4s} %{color:reset} %{message}`)
backend := gologging.NewLogBackend(os.Stdout, "", 0)
backendFormatter := gologging.NewBackendFormatter(backend, format)
leveledBackend = gologging.AddModuleLevel(backendFormatter)
gologging.SetBackend(leveledBackend)
SetLogLevel(SILENT)
}
func initLogging(level logging.Level, color bool) {
format := logging.MustStringFormatter(logFormat)
logging.SetFormatter(format)
bk := logging.NewLogBackend(os.Stdout, "", 0)
bk.Color = true
bkLvd := logging.AddModuleLevel(bk)
for _, s := range logModules {
bkLvd.SetLevel(level, s)
}
logging.SetBackend(bkLvd)
}
// initialize logging using this LogConfig;
// it panics if l.Format is invalid or l.Level is invalid
func (l *LogConfig) InitLogger() {
l.initLevel()
format := logging.MustStringFormatter(l.Format)
logging.SetFormatter(format)
for _, s := range l.Modules {
logging.SetLevel(l.level, s)
}
stdout := logging.NewLogBackend(os.Stdout, "", 0)
stdout.Color = l.Colors
logging.SetBackend(stdout)
}
func configureLogging(verbose bool) {
backend := log.NewLogBackend(os.Stdout, "", 0)
f := "%{time:15:04:05.000} %{module} ▶ %{level:.5s} %{id:03x} %{message}"
// f = "%{time:15:04:05.000} %{module} ▶ %{level:.5s} %{id:03x} %{message}"
format := log.MustStringFormatter(f)
formatter := log.NewBackendFormatter(backend, format)
log.SetBackend(formatter)
log.SetLevel(log.ERROR, "lidc")
if verbose {
log.SetLevel(log.DEBUG, "lidc")
}
}
func initLog(logConfig map[string]interface{}) {
mainLogger.Info("LogConfig: %v", logConfig)
_, ok := logConfig["level"]
if ok {
switch logConfig["level"].(string) {
case "debug":
logger.SetLevel(logger.NOTICE, moduleName)
case "error":
logger.SetLevel(logger.ERROR, moduleName)
case "info":
logger.SetLevel(logger.INFO, moduleName)
case "warn":
logger.SetLevel(logger.WARNING, moduleName)
}
}
f, err := logger.NewStringFormatter("%{shortfile} %{time:2006-01-02T15:04:05} %{level:.1s} %{id:04d} %{module} %{message}")
if err != nil {
mainLogger.Info("failed to set format: %s", err)
}
logger.SetFormatter(f)
_, ok = logConfig["file"]
if ok {
logFileName := logConfig["file"].(string)
logFile, err := os.OpenFile(logFileName, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
backend := logger.NewLogBackend(logFile, "", 0)
if err != nil {
mainLogger.Error("Failed to open log file - " + logFileName)
panic(err)
} else {
logger.SetBackend(backend)
}
} else {
backend := logger.NewLogBackend(os.Stdout, "", 0)
logger.SetBackend(backend)
}
}
func init() {
var format = "%{color}%{time:15:04:05.000000} ▶ %{level:.4s} %{color:reset} %{message}"
logBackend := logging.NewLogBackend(os.Stderr, "", 0)
logging.SetFormatter(logging.MustStringFormatter(format))
logging.SetBackend(logBackend)
input.SetLogger(log)
tbl.SetLogger(log)
route.SetLogger(log)
destination.SetLogger(log)
telnet.SetLogger(log)
web.SetLogger(log)
}
func ConfigureLog(logPath string, headless bool) *gologging.Logger {
var log = gologging.MustGetLogger("vamp-router")
var backend *gologging.LogBackend
var format = gologging.MustStringFormatter(
"%{color}%{time:15:04:05.000} %{shortpkg:.4s} %{level:.4s} ==> %{color:reset} %{message}",
)
// mix in the Lumberjack logger so we can have rotation on log files
if headless {
if len(logPath) > 0 {
backend = gologging.NewLogBackend(io.MultiWriter(&lumberjack.Logger{
Filename: logPath,
MaxSize: 50, // megabytes
MaxBackups: 2, //days
MaxAge: 14,
}), "", 0)
}
} else {
if len(logPath) > 0 {
backend = gologging.NewLogBackend(io.MultiWriter(&lumberjack.Logger{
Filename: logPath,
MaxSize: 50, // megabytes
MaxBackups: 2, //days
MaxAge: 14,
}, os.Stdout), "", 0)
}
}
backendFormatter := gologging.NewBackendFormatter(backend, format)
gologging.SetBackend(backendFormatter)
return log
}
func init() {
Log = Logger{
log: gologging.MustGetLogger(defaultModule),
}
Log.log.ExtraCalldepth = 1
format = gologging.MustStringFormatter("%{time:2006-01-02T15:04:05.000000Z} %{shortfunc:.6s} %{level}: %{message}")
backend := gologging.NewLogBackend(os.Stdout, "", 0)
backendFormatter := gologging.NewBackendFormatter(backend, format)
leveledBackend := gologging.AddModuleLevel(backendFormatter)
backends = append(backends, leveledBackend)
gologging.SetBackend(backends...)
SetLevel(SILENT)
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// 2way of run
// - 1st: cmd web
// call from brower: http://localhost:8080/main/core/1418,1419,2502,2694,2932,2933,2695
// - 2nd: cmd core/graphite 1418,1419,2502,2694,2932,2933,2695
//////////////////////////////////////////////////////////////////////////////////////////////////////
func main() {
LOGFILE, err := os.OpenFile(LOGPATH, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
LOG.Fatalf("Log file error: %s %s", LOGPATH, err)
}
defer func() {
LOGFILE.WriteString(fmt.Sprintf("closing %s", time.UnixDate))
LOGFILE.Close()
}()
logback := logging.NewLogBackend(LOGFILE, "", 0)
logformatted := logging.NewBackendFormatter(logback, LOGFORMAT)
loglevel := "DEBUG"
GLOGLEVEL, err := logging.LogLevel(loglevel)
if err != nil {
GLOGLEVEL = logging.DEBUG
}
logging.SetBackend(logformatted)
logging.SetLevel(GLOGLEVEL, "")
programName := os.Args[0:1]
if len(os.Args) < 2 {
HCIDS = append(HCIDS, 1418, 1419, 2502, 2694, 2932, 2933, 2695)
mainExec()
} else {
typeStr := os.Args[1:2]
if len(os.Args) >= 3 {
hcidStr := os.Args[2:3]
allArgs := os.Args[1:]
fmt.Println(programName, typeStr, hcidStr, allArgs)
arry := strings.Split(hcidStr[0], ",")
for i := range arry {
n, _ := strconv.Atoi(arry[i])
HCIDS = append(HCIDS, n)
}
} else {
allArgs := os.Args[1:]
fmt.Println(programName, typeStr, allArgs)
}
if typeStr[0] == "web" {
webserver()
} else {
STYPE = typeStr[0]
mainExec()
}
}
fmt.Println(HCIDS)
}
func configureLogging(colorLogs bool) {
golog.SetFormatter(golog.MustStringFormatter("[0x%{id:x}] [%{level}] [%{module}] %{message}"))
stdoutLogBackend := golog.NewLogBackend(os.Stdout, "", stdlog.LstdFlags|stdlog.Lshortfile)
stdoutLogBackend.Color = colorLogs
golog.SetBackend(stdoutLogBackend)
golog.SetLevel(golog.DEBUG, "")
// test logs
jabberwocky, err := ioutil.ReadFile("the_jabberwocky.txt")
if err != nil {
log.Warning("Failed to read \"The Jabberwocky\", it looks like nonsense")
return
}
log.Notice(fmt.Sprintf("\n\n%s", string(jabberwocky)))
}
// SetupLOG sets up logger with the correct parameters for the whole cilium architecture.
func SetupLOG(logger *l.Logger, logLevel string) {
hostname, _ := os.Hostname()
fileFormat := l.MustStringFormatter(
`%{time:` + RFC3339Milli + `} ` + hostname +
` %{level:.4s} %{id:03x} %{shortfunc} > %{message}`,
)
level, err := l.LogLevel(logLevel)
if err != nil {
logger.Fatal(err)
}
backend := l.NewLogBackend(os.Stderr, "", 0)
oBF := l.NewBackendFormatter(backend, fileFormat)
backendLeveled := l.SetBackend(oBF)
backendLeveled.SetLevel(level, "")
logger.SetBackend(backendLeveled)
}
func main() {
var loglevel string
client := &clientImpl{doneChan: make(chan struct{})}
backend := logging.NewLogBackend(os.Stderr, "", 0)
logging.SetBackend(backend)
formatter := logging.MustStringFormatter("[%{time:15:04:05}] %{shortfile:18s}: %{color}[%{level:-5s}]%{color:reset} %{message}")
logging.SetFormatter(formatter)
logger = logging.MustGetLogger(pkgName)
flag.StringVar(&loglevel, "loglevel", "info",
"The logging level. (Suggested values: info, debug)")
flag.StringVar(&client.config.server, "server",
"127.0.0.1:7050", "The RPC server to connect to.")
flag.StringVar(&client.config.cmd.cmd, "cmd", "new-chain",
"The action that this client is requesting via the config transaction.")
flag.StringVar(&client.config.cmd.args.creationPolicy, "creationPolicy", "AcceptAllPolicy",
"In case of a new-chain command, the chain createion policy this request should be validated against.")
flag.StringVar(&client.config.cmd.args.chainID, "chainID", "NewChainID",
"In case of a new-chain command, the chain ID to create.")
flag.Parse()
client.config.logLevel, _ = logging.LogLevel(strings.ToUpper(loglevel))
logging.SetLevel(client.config.logLevel, logger.Module)
conn, err := grpc.Dial(client.config.server, grpc.WithInsecure())
if err != nil {
logger.Fatalf("Client did not connect to %s: %v", client.config.server, err)
}
defer conn.Close()
client.rpc = ab.NewAtomicBroadcastClient(conn)
switch client.config.cmd.cmd {
case "new-chain":
envelope := newChainRequest(client.config.cmd.args.creationPolicy, client.config.cmd.args.chainID)
logger.Infof("Requesting the creation of chain \"%s\"", client.config.cmd.args.chainID)
client.broadcast(envelope)
default:
panic("Invalid cmd given")
}
}
func BenchmarkGologgingTextPositive(b *testing.B) {
stream := &blackholeStream{}
logger := log.MustGetLogger("")
subBackend := log.NewLogBackend(stream, "", 0)
formatter := log.MustStringFormatter("%{time:2006-01-02T15:04:05Z07:00} %{level} %{message}")
backend := log.NewBackendFormatter(subBackend, formatter)
leveled := log.AddModuleLevel(backend)
logger.SetBackend(leveled)
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
logger.Info("The quick brown fox jumps over the lazy dog")
}
})
if stream.WriteCount() != uint64(b.N) {
b.Fatalf("Log write count")
}
}