How to use Debug method of logger Package

...15		return zapfilter.NewFilteringCore(c, zapfilter.MustParseRules("demo*"))16	})17	logger := zap.NewExample()18	defer logger.Sync()19	logger.WithOptions(filtered).Debug("hello world!")20	logger.WithOptions(filtered).Named("demo").Debug("hello earth!")21	logger.WithOptions(filtered).Named("other").Debug("hello universe!")22	// Output:23	// {"level":"debug","logger":"demo","msg":"hello earth!"}24}25func ExampleNewFilteringCore_newlogger() {26	c := zap.NewExample().Core()27	logger := zap.New(zapfilter.NewFilteringCore(c, zapfilter.MustParseRules("demo*")))28	defer logger.Sync()29	logger.Debug("hello world!")30	logger.Named("demo").Debug("hello earth!")31	logger.Named("other").Debug("hello universe!")32	// Output:33	// {"level":"debug","logger":"demo","msg":"hello earth!"}34}35func ExampleFilterFunc_custom() {36	rand.Seed(42)37	core := zap.NewExample().Core()38	filterFunc := func(entry zapcore.Entry, fields []zapcore.Field) bool {39		return rand.Intn(2) == 140	}41	logger := zap.New(zapfilter.NewFilteringCore(core, filterFunc))42	defer logger.Sync()43	logger.Debug("hello city!")44	logger.Debug("hello region!")45	logger.Debug("hello planet!")46	logger.Debug("hello solar system!")47	logger.Debug("hello universe!")48	logger.Debug("hello multiverse!")49	// Output:50	// {"level":"debug","msg":"hello city!"}51	// {"level":"debug","msg":"hello solar system!"}52}53func ExampleByNamespaces() {54	core := zap.NewExample().Core()55	logger := zap.New(zapfilter.NewFilteringCore(core, zapfilter.ByNamespaces("demo1.*,demo3.*")))56	defer logger.Sync()57	logger.Debug("hello city!")58	logger.Named("demo1.frontend").Debug("hello region!")59	logger.Named("demo2.frontend").Debug("hello planet!")60	logger.Named("demo3.frontend").Debug("hello solar system!")61	// Output:62	// {"level":"debug","logger":"demo1.frontend","msg":"hello region!"}63	// {"level":"debug","logger":"demo3.frontend","msg":"hello solar system!"}64}65func ExampleParseRules() {66	core := zap.NewExample().Core()67	// *=myns             => any level, myns namespace68	// info,warn:myns.*   => info or warn level, any namespace matching myns.*69	// error=*            => everything with error level70	logger := zap.New(zapfilter.NewFilteringCore(core, zapfilter.MustParseRules("*:myns info,warn:myns.* error:*")))71	defer logger.Sync()72	logger.Debug("top debug")                                 // no match73	logger.Named("myns").Debug("myns debug")                  // matches *:myns74	logger.Named("bar").Debug("bar debug")                    // no match75	logger.Named("myns").Named("foo").Debug("myns.foo debug") // no match76	logger.Info("top info")                                 // no match77	logger.Named("myns").Info("myns info")                  // matches *:myns78	logger.Named("bar").Info("bar info")                    // no match79	logger.Named("myns").Named("foo").Info("myns.foo info") // matches info,warn:myns.*80	logger.Warn("top warn")                                 // no match81	logger.Named("myns").Warn("myns warn")                  // matches *:myns82	logger.Named("bar").Warn("bar warn")                    // no match83	logger.Named("myns").Named("foo").Warn("myns.foo warn") // matches info,warn:myns.*84	logger.Error("top error")                                 // matches error:*85	logger.Named("myns").Error("myns error")                  // matches *:myns and error:*86	logger.Named("bar").Error("bar error")                    // matches error:*87	logger.Named("myns").Named("foo").Error("myns.foo error") // matches error:*88	// Output:89	// {"level":"debug","logger":"myns","msg":"myns debug"}90	// {"level":"info","logger":"myns","msg":"myns info"}91	// {"level":"info","logger":"myns.foo","msg":"myns.foo info"}92	// {"level":"warn","logger":"myns","msg":"myns warn"}93	// {"level":"warn","logger":"myns.foo","msg":"myns.foo warn"}94	// {"level":"error","msg":"top error"}95	// {"level":"error","logger":"myns","msg":"myns error"}96	// {"level":"error","logger":"bar","msg":"bar error"}97	// {"level":"error","logger":"myns.foo","msg":"myns.foo error"}98}99func TestFilterFunc(t *testing.T) {100	t.Parallel()101	cases := []struct {102		name         string103		filterFunc   zapfilter.FilterFunc104		expectedLogs []string105	}{106		{107			"allow-all",108			func(entry zapcore.Entry, fields []zapcore.Field) bool {109				return true110			},111			[]string{"a", "b", "c", "d"},112		}, {113			"disallow-all",114			func(entry zapcore.Entry, fields []zapcore.Field) bool {115				return false116			},117			[]string{},118		}, {119			"minimum-debug",120			zapfilter.MinimumLevel(zapcore.DebugLevel),121			[]string{"a", "b", "c", "d"},122		}, {123			"minimum-info",124			zapfilter.MinimumLevel(zapcore.InfoLevel),125			[]string{"b", "c", "d"},126		}, {127			"minimum-warn",128			zapfilter.MinimumLevel(zapcore.WarnLevel),129			[]string{"c", "d"},130		}, {131			"minimum-error",132			zapfilter.MinimumLevel(zapcore.ErrorLevel),133			[]string{"d"},134		}, {135			"exact-debug",136			zapfilter.ExactLevel(zapcore.DebugLevel),137			[]string{"a"},138		}, {139			"exact-info",140			zapfilter.ExactLevel(zapcore.InfoLevel),141			[]string{"b"},142		}, {143			"exact-warn",144			zapfilter.ExactLevel(zapcore.WarnLevel),145			[]string{"c"},146		}, {147			"exact-error",148			zapfilter.ExactLevel(zapcore.ErrorLevel),149			[]string{"d"},150		}, {151			"all-except-debug",152			zapfilter.Reverse(zapfilter.ExactLevel(zapcore.DebugLevel)),153			[]string{"b", "c", "d"},154		}, {155			"all-except-info",156			zapfilter.Reverse(zapfilter.ExactLevel(zapcore.InfoLevel)),157			[]string{"a", "c", "d"},158		}, {159			"all-except-warn",160			zapfilter.Reverse(zapfilter.ExactLevel(zapcore.WarnLevel)),161			[]string{"a", "b", "d"},162		}, {163			"all-except-error",164			zapfilter.Reverse(zapfilter.ExactLevel(zapcore.ErrorLevel)),165			[]string{"a", "b", "c"},166		}, {167			"any",168			zapfilter.Any(169				zapfilter.ExactLevel(zapcore.DebugLevel),170				zapfilter.ExactLevel(zapcore.WarnLevel),171			),172			[]string{"a", "c"},173		}, {174			"all-1",175			zapfilter.All(176				zapfilter.ExactLevel(zapcore.DebugLevel),177				zapfilter.ExactLevel(zapcore.WarnLevel),178			),179			[]string{},180		}, {181			"all-2",182			zapfilter.All(183				zapfilter.ExactLevel(zapcore.DebugLevel),184				zapfilter.ExactLevel(zapcore.DebugLevel),185			),186			[]string{"a"},187		},188	}189	for _, tc := range cases {190		t.Run(tc.name, func(t *testing.T) {191			t.Parallel()192			next, logs := observer.New(zapcore.DebugLevel)193			core := zapfilter.NewFilteringCore(next, tc.filterFunc)194			logger := zap.New(core)195			logger.Debug("a")196			logger.Info("b")197			logger.Warn("c")198			logger.Error("d")199			gotLogs := []string{}200			for _, log := range logs.All() {201				gotLogs = append(gotLogs, log.Message)202			}203			require.Equal(t, gotLogs, tc.expectedLogs)204		})205	}206}207func TestParseRules(t *testing.T) {208	t.Parallel()209	const (210		allDebug   = "aeimquy2"211		allInfo    = "bfjnrvz3"212		allWarn    = "cgkosw04"213		allError   = "dhlptx15"214		everything = "abcdefghijklmnopqrstuvwxyz012345"215	)216	cases := []struct {217		name          string218		input         string219		expectedLogs  string220		expectedError error221	}{222		{"empty", "", "", nil},223		{"everything", "*", everything, nil},224		{"debug+", "debug+:*", everything, nil},225		{"all-debug", "debug:*", allDebug, nil},226		{"all-info", "info:*", allInfo, nil},227		{"all-warn", "warn:*", allWarn, nil},228		{"all-error", "error:*", allError, nil},229		{"all-info-and-warn-1", "info,warn:*", "bcfgjknorsvwz034", nil},230		{"all-info-and-warn-2", "info:* warn:*", "bcfgjknorsvwz034", nil},231		{"warn+", "warn+:*", "cdghklopstwx0145", nil},232		{"redundant-1", "info,info:* info:*", allInfo, nil},233		{"redundant-2", "* *:* info:*", everything, nil},234		{"foo-ns", "foo", "efgh", nil},235		{"foo-ns-wildcard", "*:foo", "efgh", nil},236		{"foo-ns-debug,info", "debug,info:foo", "ef", nil},237		{"foo.star-ns", "foo.*", "qrstuvwx", nil},238		{"foo.star-ns-wildcard", "*:foo.*", "qrstuvwx", nil},239		{"foo.star-ns-debug,info", "debug,info:foo.*", "qruv", nil},240		{"all-in-one", "*:foo debug:foo.* info,warn:bar error:*", "defghjklpqtux15", nil},241		{"exclude-1", "info:test,foo*,-foo.foo", "fr", nil},242		{"exclude-2", "info:test,foo*,-*.foo", "fr", nil},243		{"exclude-3", "test,*.foo,-foo.*", "yz012345", nil},244		{"exclude-4", "*,-foo,-bar", "abcdmnopqrstuvwxyz012345", nil},245		{"exclude-5", "foo*,bar*,-foo.foo,-bar.foo", "efghijklqrst", nil},246		{"exclude-6", "foo*,-foo.foo,bar*,-bar.foo", "efghijklqrst", nil},247		{"invalid-left", "invalid:*", "", fmt.Errorf(`unsupported keyword: "invalid"`)},248		{"missing-left", ":*", "", fmt.Errorf(`bad syntax`)},249		{"missing-right", ":*", "", fmt.Errorf(`bad syntax`)},250		//{"missing-exclude-pattern", "*:-", "", fmt.Errorf(`bad syntax`)},251	}252	for _, tc := range cases {253		t.Run(tc.name, func(t *testing.T) {254			//t.Parallel()255			next, logs := observer.New(zapcore.DebugLevel)256			filter, err := zapfilter.ParseRules(tc.input)257			require.Equal(t, tc.expectedError, err)258			if err != nil {259				return260			}261			core := zapfilter.NewFilteringCore(next, filter)262			logger := zap.New(core)263			logger.Debug("a")264			logger.Info("b")265			logger.Warn("c")266			logger.Error("d")267			logger.Named("foo").Debug("e")268			logger.Named("foo").Info("f")269			logger.Named("foo").Warn("g")270			logger.Named("foo").Error("h")271			logger.Named("bar").Debug("i")272			logger.Named("bar").Info("j")273			logger.Named("bar").Warn("k")274			logger.Named("bar").Error("l")275			logger.Named("baz").Debug("m")276			logger.Named("baz").Info("n")277			logger.Named("baz").Warn("o")278			logger.Named("baz").Error("p")279			logger.Named("foo").Named("bar").Debug("q")280			logger.Named("foo").Named("bar").Info("r")281			logger.Named("foo").Named("bar").Warn("s")282			logger.Named("foo").Named("bar").Error("t")283			logger.Named("foo").Named("foo").Debug("u")284			logger.Named("foo").Named("foo").Info("v")285			logger.Named("foo").Named("foo").Warn("w")286			logger.Named("foo").Named("foo").Error("x")287			logger.Named("bar").Named("foo").Debug("y")288			logger.Named("bar").Named("foo").Info("z")289			logger.Named("bar").Named("foo").Warn("0")290			logger.Named("bar").Named("foo").Error("1")291			logger.Named("qux").Named("foo").Debug("2")292			logger.Named("qux").Named("foo").Info("3")293			logger.Named("qux").Named("foo").Warn("4")294			logger.Named("qux").Named("foo").Error("5")295			gotLogs := []string{}296			for _, log := range logs.All() {297				gotLogs = append(gotLogs, log.Message)298			}299			require.Equal(t, tc.expectedLogs, strings.Join(gotLogs, ""))300		})301	}302}303func TestCheck(t *testing.T) {304	cases := []struct {305		rules     string306		namespace string307		checked   bool308	}{309		{"", "", false},310		{"", "foo", false},311		{"*", "", true},312		{"*", "foo", true},313		{"*:foo", "", false},314		{"*:foo", "foo", true},315		{"*:foo", "bar", false},316	}317	for _, tc := range cases {318		name := fmt.Sprintf("%s-%s", tc.rules, tc.namespace)319		t.Run(name, func(t *testing.T) {320			next, _ := observer.New(zapcore.DebugLevel)321			filter, err := zapfilter.ParseRules(tc.rules)322			if err != nil {323				return324			}325			core := zapfilter.NewFilteringCore(next, filter)326			logger := zap.New(core)327			if tc.namespace != "" {328				logger = logger.Named(tc.namespace)329			}330			entry := logger.Check(zap.DebugLevel, "")331			if tc.checked {332				require.NotNil(t, entry)333			} else {334				require.Nil(t, entry)335			}336		})337	}338}339func Example_check() {340	c := zap.NewExample().Core()341	logger := zap.New(zapfilter.NewFilteringCore(c, zapfilter.MustParseRules("debug:* info:demo*")))342	if ce := logger.Check(zap.DebugLevel, "AAA"); ce != nil {343		// here you can make expensive computing344		fmt.Println("BBB")345		ce.Write()346	}347	if ce := logger.Check(zap.InfoLevel, "CCC"); ce != nil {348		// here you can make expensive computing349		fmt.Println("DDD")350		ce.Write()351	}352	if ce := logger.Named("demo").Check(zap.InfoLevel, "EEE"); ce != nil {353		// here you can make expensive computing354		fmt.Println("FFF")355		ce.Write()356	}357	if ce := logger.Check(zap.WarnLevel, "GGG"); ce != nil {358		// here you can make expensive computing359		fmt.Println("HHH")360		ce.Write()361	}362	// Output:363	// BBB364	// {"level":"debug","msg":"AAA"}365	// FFF366	// {"level":"info","logger":"demo","msg":"EEE"}367}368func ExampleCheckAnyLevel() {369	c := zap.NewExample().Core()370	logger := zap.New(zapfilter.NewFilteringCore(c, zapfilter.MustParseRules("debug:*.* info:demo*")))371	fmt.Println(zapfilter.CheckAnyLevel(logger))372	fmt.Println(zapfilter.CheckAnyLevel(logger.Named("demo")))373	fmt.Println(zapfilter.CheckAnyLevel(logger.Named("blahdemo")))374	fmt.Println(zapfilter.CheckAnyLevel(logger.Named("demoblah")))375	fmt.Println(zapfilter.CheckAnyLevel(logger.Named("blah")))376	fmt.Println(zapfilter.CheckAnyLevel(logger.Named("blah.blah")))377	// Output:378	// false379	// true380	// false381	// true382	// false383	// true384}385func ExampleCheckLevel() {386	c := zap.NewExample().Core()387	logger := zap.New(zapfilter.NewFilteringCore(c, zapfilter.MustParseRules("debug:*.* info:demo*")))388	fmt.Println(zapfilter.CheckLevel(logger, zap.DebugLevel))389	fmt.Println(zapfilter.CheckLevel(logger.Named("demo"), zap.DebugLevel))390	fmt.Println(zapfilter.CheckLevel(logger.Named("blahdemo"), zap.DebugLevel))391	fmt.Println(zapfilter.CheckLevel(logger.Named("demoblah"), zap.DebugLevel))392	fmt.Println(zapfilter.CheckLevel(logger.Named("blah"), zap.DebugLevel))393	fmt.Println(zapfilter.CheckLevel(logger.Named("blah.blah"), zap.DebugLevel))394	fmt.Println(zapfilter.CheckLevel(logger, zap.InfoLevel))395	fmt.Println(zapfilter.CheckLevel(logger.Named("demo"), zap.InfoLevel))396	fmt.Println(zapfilter.CheckLevel(logger.Named("blahdemo"), zap.InfoLevel))397	fmt.Println(zapfilter.CheckLevel(logger.Named("demoblah"), zap.InfoLevel))398	fmt.Println(zapfilter.CheckLevel(logger.Named("blah"), zap.InfoLevel))399	fmt.Println(zapfilter.CheckLevel(logger.Named("blah.blah"), zap.InfoLevel))400	// Output:401	// false402	// false403	// false404	// false405	// false406	// true407	// false408	// true409	// false410	// true411	// false412	// false413}414func Example_with() {415	core := zap.NewExample().Core()416	logger := zap.New(zapfilter.NewFilteringCore(core, zapfilter.ByNamespaces("demo1.*,demo3.*")))417	defer logger.Sync()418	logger.With(zap.String("lorem", "ipsum")).Debug("hello city!")419	logger.With(zap.String("lorem", "ipsum")).Named("demo1.frontend").Debug("hello region!")420	logger.With(zap.String("lorem", "ipsum")).Named("demo2.frontend").Debug("hello planet!")421	logger.With(zap.String("lorem", "ipsum")).Named("demo3.frontend").Debug("hello solar system!")422	// Output:423	// {"level":"debug","logger":"demo1.frontend","msg":"hello region!","lorem":"ipsum"}424	// {"level":"debug","logger":"demo3.frontend","msg":"hello solar system!","lorem":"ipsum"}425}...

...19	}{20		{21			spec:                 "DEBUG",22			expectedLevels:       map[string]zapcore.Level{},23			expectedDefaultLevel: zapcore.DebugLevel,24		},25		{26			spec:                 "INFO",27			expectedLevels:       map[string]zapcore.Level{},28			expectedDefaultLevel: zapcore.InfoLevel,29		},30		{31			spec: "logger=info:DEBUG",32			expectedLevels: map[string]zapcore.Level{33				"logger":     zapcore.InfoLevel,34				"logger.a":   zapcore.InfoLevel,35				"logger.b":   zapcore.InfoLevel,36				"logger.a.b": zapcore.InfoLevel,37			},38			expectedDefaultLevel: zapcore.DebugLevel,39		},40		{41			spec: "logger=info:logger.=error:DEBUG",42			expectedLevels: map[string]zapcore.Level{43				"logger":     zapcore.ErrorLevel,44				"logger.a":   zapcore.InfoLevel,45				"logger.b":   zapcore.InfoLevel,46				"logger.a.b": zapcore.InfoLevel,47			},48			expectedDefaultLevel: zapcore.DebugLevel,49		},50		{51			spec: "logger.a,logger.b=info:logger.c=WARN:DEBUG",52			expectedLevels: map[string]zapcore.Level{53				"logger.a": zapcore.InfoLevel,54				"logger.b": zapcore.InfoLevel,55				"logger.c": zapcore.WarnLevel,56			},57			expectedDefaultLevel: zapcore.DebugLevel,58		},59		{60			spec: "a.b=info:a,z=error:c.b=info:c.=warn:debug",61			expectedLevels: map[string]zapcore.Level{62				"a":       zapcore.ErrorLevel,63				"z":       zapcore.ErrorLevel,64				"a.b":     zapcore.InfoLevel,65				"a.b.c":   zapcore.InfoLevel,66				"a.b.c.d": zapcore.InfoLevel,67				"a.c":     zapcore.ErrorLevel,68				"c":       zapcore.WarnLevel,69				"c.a":     zapcore.DebugLevel,70				"c.b":     zapcore.InfoLevel,71				"d":       zapcore.DebugLevel,72				"ab.c":    zapcore.DebugLevel,73				"c.b.a":   zapcore.InfoLevel,74				"c.b.a.b": zapcore.InfoLevel,75			},76			expectedDefaultLevel: zapcore.DebugLevel,77		},78		{79			spec: "info:warn",80			expectedLevels: map[string]zapcore.Level{81				"a":   zapcore.WarnLevel,82				"a.b": zapcore.WarnLevel,83				"b":   zapcore.WarnLevel,84				"c":   zapcore.WarnLevel,85				"d":   zapcore.WarnLevel,86			},87			expectedDefaultLevel: zapcore.WarnLevel,88		},89	}90	for _, tc := range tests {91		t.Run(tc.spec, func(t *testing.T) {92			ll := &flogging.LoggerLevels{}93			err := ll.ActivateSpec(tc.spec)94			require.NoError(t, err)95			require.Equal(t, tc.expectedDefaultLevel, ll.DefaultLevel())96			for name, lvl := range tc.expectedLevels {97				require.Equal(t, lvl, ll.Level(name))98			}99		})100	}101}102func TestLoggerLevelsActivateSpecErrors(t *testing.T) {103	var tests = []struct {104		spec string105		err  error106	}{107		{spec: "=INFO:DEBUG", err: errors.New("invalid logging specification '=INFO:DEBUG': no logger specified in segment '=INFO'")},108		{spec: "=INFO=:DEBUG", err: errors.New("invalid logging specification '=INFO=:DEBUG': bad segment '=INFO='")},109		{spec: "bogus", err: errors.New("invalid logging specification 'bogus': bad segment 'bogus'")},110		{spec: "a.b=info:a=broken:c.b=info:c.=warn:debug", err: errors.New("invalid logging specification 'a.b=info:a=broken:c.b=info:c.=warn:debug': bad segment 'a=broken'")},111		{spec: "a*=info:debug", err: errors.New("invalid logging specification 'a*=info:debug': bad logger name 'a*'")},112		{spec: ".a=info:debug", err: errors.New("invalid logging specification '.a=info:debug': bad logger name '.a'")},113	}114	for _, tc := range tests {115		t.Run(tc.spec, func(t *testing.T) {116			ll := &flogging.LoggerLevels{}117			err := ll.ActivateSpec("fatal:a=warn")118			require.Nil(t, err)119			err = ll.ActivateSpec(tc.spec)120			require.EqualError(t, err, tc.err.Error())121			require.Equal(t, zapcore.FatalLevel, ll.DefaultLevel(), "default should not change")122			require.Equal(t, zapcore.WarnLevel, ll.Level("a.b"), "log levels should not change")123		})124	}125}126func TestSpec(t *testing.T) {127	var tests = []struct {128		input  string129		output string130	}{131		{input: "", output: "info"},132		{input: "debug", output: "debug"},133		{input: "a.=info:warning", output: "a.=info:warn"},134		{input: "a-b=error", output: "a-b=error:info"},135		{input: "a#b=error", output: "a#b=error:info"},136		{input: "a_b=error", output: "a_b=error:info"},137		{input: "debug:a=info:b=warn", output: "a=info:b=warn:debug"},138		{input: "b=warn:a=error", output: "a=error:b=warn:info"},139	}140	for _, tc := range tests {141		ll := &flogging.LoggerLevels{}142		err := ll.ActivateSpec(tc.input)143		require.NoError(t, err)144		require.Equal(t, tc.output, ll.Spec())145	}146}147func TestEnabled(t *testing.T) {148	var tests = []struct {149		spec      string150		enabledAt zapcore.Level151	}{152		{spec: "payload", enabledAt: flogging.PayloadLevel},153		{spec: "debug", enabledAt: zapcore.DebugLevel},154		{spec: "info", enabledAt: zapcore.InfoLevel},155		{spec: "warn", enabledAt: zapcore.WarnLevel},156		{spec: "panic", enabledAt: zapcore.PanicLevel},157		{spec: "fatal", enabledAt: zapcore.FatalLevel},158		{spec: "fatal:a=debug", enabledAt: zapcore.DebugLevel},159		{spec: "a=fatal:b=warn", enabledAt: zapcore.InfoLevel},160		{spec: "a=warn", enabledAt: zapcore.InfoLevel},161		{spec: "a=debug", enabledAt: zapcore.DebugLevel},162	}163	for i, tc := range tests {164		t.Run(strconv.Itoa(i), func(t *testing.T) {165			ll := &flogging.LoggerLevels{}166			err := ll.ActivateSpec(tc.spec)167			require.NoError(t, err)168			for i := flogging.PayloadLevel; i <= zapcore.FatalLevel; i++ {169				if tc.enabledAt <= i {170					require.Truef(t, ll.Enabled(i), "expected level %s and spec %s to be enabled", zapcore.Level(i), tc.spec)171				} else {172					require.False(t, ll.Enabled(i), "expected level %s and spec %s to be disabled", zapcore.Level(i), tc.spec)173				}174			}175		})...

...29	// LogLevelWarning is the level that warning messages are written30	logLevelWarning = 231	// LogLevelInfo is the level that info messages are written32	logLevelInfo = 333	// LogLevelDebug is the level that debug messages are written34	logLevelDebug = 435)36type internalLogger struct {37	level         logLevel38	errorLogger   *log.Logger39	warningLogger *log.Logger40	infoLogger    *log.Logger41	debugLogger   *log.Logger42}43func simpleLogger(level logLevel, writer io.Writer) gobolt.Logging {44	return &internalLogger{45		level:         level,46		errorLogger:   log.New(writer, "ERROR  : ", log.Ldate|log.Ltime|log.Lmicroseconds),47		warningLogger: log.New(writer, "WARNING: ", log.Ldate|log.Ltime|log.Lmicroseconds),48		infoLogger:    log.New(writer, "INFO   : ", log.Ldate|log.Ltime|log.Lmicroseconds),49		debugLogger:   log.New(writer, "DEBUG  : ", log.Ldate|log.Ltime|log.Lmicroseconds),50	}51}52func (logger *internalLogger) ErrorEnabled() bool {53	return logLevelError <= logger.level54}55func (logger *internalLogger) WarningEnabled() bool {56	return logLevelWarning <= logger.level57}58func (logger *internalLogger) InfoEnabled() bool {59	return logLevelInfo <= logger.level60}61func (logger *internalLogger) DebugEnabled() bool {62	return logLevelDebug <= logger.level63}64func (logger *internalLogger) Errorf(message string, args ...interface{}) {65	logger.errorLogger.Printf(message, args...)66}67func (logger *internalLogger) Warningf(message string, args ...interface{}) {68	logger.warningLogger.Printf(message, args...)69}70func (logger *internalLogger) Infof(message string, args ...interface{}) {71	logger.infoLogger.Printf(message, args...)72}73func (logger *internalLogger) Debugf(message string, args ...interface{}) {74	logger.debugLogger.Printf(message, args...)75}...

1import (2func main() {3	log.SetFlags(0)4	log.SetPrefix("TRACE: ")5	log.Println("I have something standard to say")6	log.SetPrefix("INFO: ")7	log.Println("Special Information")8	log.SetPrefix("ERROR: ")9	log.Println("Something has failed")10}11import (12func main() {13	log.SetFlags(0)14	log.SetPrefix("TRACE: ")15	log.Println("I have something standard to say")16	log.SetPrefix("INFO: ")17	log.Println("Special Information")18	log.SetPrefix("ERROR: ")19	log.Fatalln("Something has failed")20	fmt.Println("Never print")21}22import (23func main() {24	log.SetFlags(0)25	log.SetPrefix("TRACE: ")26	log.Println("I have something standard to say")27	log.SetPrefix("INFO: ")28	log.Println("Special Information")29	log.SetPrefix("ERROR: ")30	log.Panicln("Something has failed")31	fmt.Println("Never print")32}33import (34func main() {35	log.SetFlags(0)36	log.SetPrefix("TRACE: ")37	log.Print("I have something standard to say")38	log.SetPrefix("INFO: ")39	log.Print("Special Information")40	log.SetPrefix("ERROR: ")41	log.Print("Something has failed")42}43import (44func main() {45	log.SetFlags(0)46	log.SetPrefix("TRACE: ")47	log.Printf("I have %s standard to say

1import (2func main() {3    log.SetFlags(0)4    log.SetPrefix("TRACE: ")5    log.Println("I have something standard to say")6    log.SetPrefix("INFO: ")7    log.Println("Special Information")8    log.SetPrefix("ERROR: ")9    log.Println("Something has failed")10}11import (12func main() {13    log.SetFlags(0)14    log.SetPrefix("TRACE: ")15    log.Println("I have something standard to say")16    log.SetPrefix("INFO: ")17    log.Println("Special Information")18    log.SetPrefix("ERROR: ")19    log.Fatalln("Something has failed")20    log.Println("Never print")21}22import (23func main() {24    log.SetFlags(0)25    log.SetPrefix("TRACE: ")26    log.Println("I have something standard to say")27    log.SetPrefix("INFO: ")28    log.Println("Special Information")29    log.SetPrefix("ERROR: ")30    log.Panicln("Something has failed")31    log.Println("Never print")32}33import (34func main() {35    log.SetFlags(0)36    log.SetPrefix("TRACE: ")37    log.Print("I have something standard to say")38    log.SetPrefix("INFO: ")39    log.Print("Special Information")40    log.SetPrefix("ERROR: ")41    log.Print("Something has failed")42}43import (44func main() {

1import (2func main() {3	logger := log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)4	logger.Println("This is a debug message")5	fmt.Println("Hello World!")6}

1import (2func main() {3	f, err := os.Create("log.txt")4	if err != nil {5		fmt.Println(err)6	}7	l := log.New(f, "Prefix", log.LstdFlags)8	l.Println("Text to append")9	l.SetFlags(log.LstdFlags | log.Lshortfile)10	l.Println("Text to append")11	mw := io.MultiWriter(os.Stdout, f)12	l1 := log.New(mw, "Prefix", log.LstdFlags)13	l1.Println("Text to append")14	l1.SetFlags(log.LstdFlags | log.Lshortfile)15	l1.Println("Text to append")16}

1import (2func main() {3	l := logger.New()4	l.Debug("This is a debug message")5}6import (7func main() {8	l := logger.New()9	l.Info("This is an info message")10}11import (12func main() {13	l := logger.New()14	l.Warn("This is a warn message")15}16import (17func main() {18	l := logger.New()19	l.Error("This is an error message")20}21import (22func main() {23	l := logger.New()24	l.Fatal("This is a fatal message")25}

1import (2func main() {3	logger.Debug("Hello world")4}5import (6func main() {7	logger.Warn("Hello world")8}9import (10func main() {11	logger.Error("Hello world")12}13import (14func main() {15	logger.Fatal("Hello world")16}17import (18func main() {19	logger.Panic("Hello world")20}21import (22func main() {23	logger.Print("Hello world")24}25import (26func main() {27	logger.Println("Hello world")28}29import (30func main() {31	logger.Printf("Hello world")32}33import (34func main() {35	logger.SetLogLevel(logger.DEBUG)36}37import (38func main() {39	logger.SetLogOutput("file")40}41import (42func main() {43	logger.SetLogOutput("console")44}45import (46func main() {47	logger.SetLogOutput("file")48}49import (50func main() {51	logger.SetLogOutput("console")52}

1import (2func main() {3	logger := log.New(os.Stdout, "logger: ", log.Lshortfile)4	logger.Print("This is a debug message")5}6import (7func main() {8	logger := log.New(os.Stdout, "logger: ", log.Lshortfile)9	logger.Print("This is a debug message")10}11import (12func main() {13	logger := log.New(os.Stdout, "logger: ", log.Lshortfile)14	logger.Print("This is a debug message")15}16import (17func main() {18	logger := log.New(os.Stdout, "logger: ", log.Lshortfile)19	logger.Print("This is a debug message")20}

1import (2func main() {3	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)4	logger.Println("This is a debug message")5}6import (7func main() {8	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)9	logger.Println("This is a debug message")10}11import (12func main() {13	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)14	logger.Println("This is a debug message")15}16import (17func main() {18	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)19	logger.Println("This is a debug message")20}21import (22func main() {23	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)24	logger.Println("This is a debug message")25}26import (27func main() {28	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)29	logger.Println("This is a debug message")30}31import (32func main() {33	logger := log.New(os.Stdout, "DEBUG: ", log.Lshortfile)34	logger.Println("This is a debug message")35}

1import (2func main() {3	log.Println("Debug message")4	fmt.Println("Debug message")5}6import (7func main() {8	log.Println("Info message")9	fmt.Println("Info message")10}11import (12func main() {13	log.Println("Warning message")14	fmt.Println("Warning message")15}16import (17func main() {18	log.Println("Error message")19	fmt.Println("Error message")20}21import (22func main() {23	log.Println("Fatal message")24	fmt.Println("Fatal message")25}26import (27func main() {28	log.Println("Panic message")29	fmt.Println("Panic message")30}