コード例 #1
0
ファイル: example.go プロジェクト: steenzout/gol
func main() {
	log.Send(&gol.LogMessage{"hello": "world!"})
	log.Send(gol.NewError("error", "info"))
	log.Send(gol.NewDebug("debug", "info"))

	errorLog.Send(&gol.LogMessage{"hello": "world!"})
	errorLog.Send(gol.NewEmergency("emergency", "errorLog"))
	errorLog.Send(gol.NewError("error", "errorLog"))
	errorLog.Send(gol.NewWarning("error", "errorLog"))
	errorLog.Send(gol.NewInfo("info", "errorLog"))
	errorLog.Send(gol.NewDebug("debug", "errorLog"))
}
コード例 #2
0
ファイル: example.go プロジェクト: steenzout/gol
func main() {
	// this will be written to stderr
	logger.Send(gol.NewEmergency("message", "system is down"))
	logger.Send(gol.NewAlert("message", "failed to write to disk"))
	logger.Send(gol.NewCritical("message", "high server load"))
	logger.Send(gol.NewError("message", "invalid number format"))

	// this will not be written anywhere
	logger.Send(gol.NewWarning("message", "performance close to 1s threshold"))
	logger.Send(gol.NewNotice("message", "failed to communicate with monitoring service"))
	logger.Send(gol.NewInfo("message", "requested processed in 250ms"))
	logger.Send(gol.NewDebug("debug", "var x = 10"))
}
コード例 #3
0
ファイル: example.go プロジェクト: steenzout/gol
func main() {
	fmt.Println("Started application.")
	defer func() {
		Log.Close()
		fmt.Println("Ended application.")
	}()

	// send 10,000 messages
	for i := 0; i < 100000; i++ {
		Log.Send(gol.NewInfo("i", fmt.Sprintf("%d", i)))
	}
	fmt.Println("Ending application...")
}
コード例 #4
0
ファイル: log.go プロジェクト: steenzout/gol
func init() {
	fmt.Println("init():start")
	Log = manager_simple.New(LogWorkers)

	f := filter_severity.New(field_severity.Info)
	formatter := formatters.Text{}
	logger := logger_simple.New(f, formatter, os.Stdout)
	Log.Register("main", logger)

	Log.Run()
	Log.Send(gol.NewInfo("message", "main.Log has been configured"))
	fmt.Println("init():end")
}
コード例 #5
0
ファイル: messages_test.go プロジェクト: steenzout/gol
func (s *MessageTestSuite) TestTimestamp() {
	var msg *gol.LogMessage

	msg = &gol.LogMessage{"key": "value"}
	v, err := msg.Timestamp()
	assert.Equal(s.T(), fmt.Errorf("Message does not contain field timestamp"), err)
	assert.Nil(s.T(), v)

	msg = gol.NewInfo("key", "value")
	v, err = msg.Timestamp()
	assert.Nil(s.T(), err)
	assert.True(s.T(), v.Before(time.Now()))
}
コード例 #6
0
ファイル: simple_test.go プロジェクト: steenzout/gol
func (s *LoggerTestSuite) TestSend() {

	in := map[string]setupLogTest{
		"error": setupLogTest{
			setUp: func(
				msg *gol.LogMessage, mf *mock.LogFilter, mfmt *mock.LogFormatter, mw *mock.Writer,
			) (logger *simple.Logger) {
				mf.Mock.On("Filter", msg).Return(false, nil)
				mfmt.Mock.On("Format", msg).Return("ERROR", nil)
				mw.Mock.On("Write", []byte("ERROR")).Return(5, nil)

				logger = simple.New(mf, mfmt, mw)

				return
			},
			message: gol.NewError(),
			output:  "ERROR",
		},
		"info": setupLogTest{
			setUp: func(
				msg *gol.LogMessage, mf *mock.LogFilter, mfmt *mock.LogFormatter, mw *mock.Writer,
			) (logger *simple.Logger) {
				mf.Mock.On("Filter", msg).Return(true, nil)

				logger = simple.New(mf, mfmt, mw)

				return
			},
			message: gol.NewInfo(),
			output:  "",
		},
	}

	for _, t := range in {
		mf := &mock.LogFilter{}
		mfmt := &mock.LogFormatter{}
		mw := &mock.Writer{}
		logger := t.setUp(t.message, mf, mfmt, mw)

		logger.Send(t.message)

		mf.AssertExpectations(s.T())
		mfmt.AssertExpectations(s.T())
		mw.AssertExpectations(s.T())
	}
}
コード例 #7
0
ファイル: example.go プロジェクト: steenzout/gol
func main() {
	log.Send(gol.NewInfo("message", "example execution started"))
	log.Send(gol.NewInfo("message", "example execution ended"))
}