Beispiel #1
0
func testLoggerHandler(t *testing.T, mgr Manager) {
	log := mgr.Logger("a/b/c/d")

	if hndl := log.Handler("test"); hndl != nil {
		t.Fatal(hndl)
	}

	memHndl := handler.NewNopHandler()
	if hndl := log.AddHandler("test", memHndl); hndl != nil {
		t.Fatal(hndl)
	}

	oldHndl := log.Handler("test")
	if oldHndl != memHndl {
		t.Fatal(oldHndl, memHndl)
	}

	memHndl = handler.NewNopHandler()
	if hndl := log.AddHandler("test", memHndl); hndl != oldHndl {
		t.Fatal(hndl, oldHndl)
	}

	if hndl := log.RemoveHandler("test"); hndl != memHndl {
		t.Fatal(hndl, memHndl)
	}

	if hndl := log.Handler("test"); hndl != nil {
		t.Fatal(hndl)
	}
}
Beispiel #2
0
func benchmarkLoggerConcurrent(b *testing.B, mgr Manager) {
	rootLabel := "a/b/c"
	conc := 100

	rootLog := mgr.Logger(rootLabel)
	rootLog.SetLevel(level.ALL)
	rootLog.SetUseParent(false)

	path := filepath.Join(os.TempDir(), "locklog_test")
	if err := os.Remove(path); err != nil {
		if !os.IsNotExist(err) {
			b.Fatal(err)
		}
	}
	defer os.Remove(path)

	hndl := handler.NewNopHandler()
	hndl.SetLevel(level.DEBUG)
	rootLog.AddHandler("test", hndl)

	c := make(chan bool)
	timeout := time.After(time.Duration(int64(conc*b.N*100) * int64(time.Microsecond)))

	for i := 0; i < conc; i++ {
		id := i
		go func() {
			for j := 0; j < b.N/conc; j++ {
				mgr.Logger(rootLabel+"/"+strconv.Itoa(id)).Info(id, j)
			}

			c <- true
		}()
	}

	for i := 0; i < conc; i++ {
		select {
		case <-c:
		case <-timeout:
			b.Fatal("Dead lock?")
		}
	}

	mgr.Flush()
}
Beispiel #3
0
func testLoggerIsLoggable(t *testing.T, mgr Manager) {
	//                    先祖にハンドラが無い 先祖の基準重要度より低い 先祖の基準重要度より高い
	// ハンドラが無い     false                false                    true
	// 基準重要度より低い false                false                    true
	// 基準重要度より高い true                 true                     true

	log := mgr.Logger("a/b/c/d")
	log.SetLevel(level.INFO)
	log.SetUseParent(true)
	parentLog := mgr.Logger("a/b")
	parentLog.SetLevel(level.INFO)
	parentLog.SetUseParent(false)

	// ハンドラが無い、先祖にハンドラが無い。
	if log.IsLoggable(level.INFO) {
		t.Fatal("true: no handler, no handler")
	}

	log.AddHandler("test", handler.NewNopHandler())

	// 基準重要度より低い、先祖にハンドラが無い。
	if log.IsLoggable(level.DEBUG) {
		t.Fatal("true: lower level, no handler")
	}

	// 基準重要度より高い、先祖にハンドラが無い。
	if !log.IsLoggable(level.INFO) {
		t.Fatal("false: upper or equal level, no handler")
	}

	log.RemoveHandler("test")
	parentLog.AddHandler("test", handler.NewNopHandler())
	parentLog.SetLevel(level.WARN)

	// ハンドラが無い、先祖の基準重要度より低い。
	if log.IsLoggable(level.INFO) {
		t.Fatal("true: no handler, lower level")
	}

	log.AddHandler("test", handler.NewNopHandler())

	// 基準重要度より低い、先祖の基準重要度より低い。
	if log.IsLoggable(level.DEBUG) {
		t.Fatal("true: lower level, lower level")
	}

	// 基準重要度より高い、先祖の基準重要度より低い。
	if !log.IsLoggable(level.INFO) {
		t.Fatal("false: upper or equal level, lower level")
	}

	log.RemoveHandler("test")
	parentLog.AddHandler("test", handler.NewNopHandler())
	parentLog.SetLevel(level.DEBUG)

	// ハンドラが無い、先祖の基準重要度より高い。
	if !log.IsLoggable(level.INFO) {
		t.Fatal("false: no handler, upper level")
	}

	log.AddHandler("test", handler.NewNopHandler())

	// 基準重要度より低い、先祖の基準重要度より高い。
	if !log.IsLoggable(level.DEBUG) {
		t.Fatal("true: lower level, upper level")
	}

	// 基準重要度より高い、先祖の基準重要度より高い。
	if !log.IsLoggable(level.INFO) {
		t.Fatal("false: upper or equal level, upper level")
	}
}