func TestDumpReturnsAllRecentMessagesToMultipleDumpRequests(t *testing.T) { var bufferSize uint bufferSize = 2 dump := NewDumpSink("myApp", bufferSize, loggertesthelper.Logger()) dump.Run() logMessage := messagetesthelpers.NewMessage(t, "1", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "3", "appId") dump.Channel() <- logMessage runtime.Gosched() logMessages := dumpAllMessages(dump, bufferSize) assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") logMessages = dumpAllMessages(dump, bufferSize) assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") }
func TestThatItSends(t *testing.T) { receivedChan := make(chan []byte, 2) expectedMessageString := "Some data" message := messagetesthelpers.NewMessage(t, expectedMessageString, "myApp01") otherMessageString := "Some more stuff" otherMessage := messagetesthelpers.NewMessage(t, otherMessageString, "myApp01") _, dontKeepAliveChan, _ := testhelpers.AddWSSink(t, receivedChan, SERVER_PORT, "/tail/?app=myApp01") WaitForWebsocketRegistration() dataReadChannel <- message dataReadChannel <- otherMessage select { case <-time.After(1 * time.Second): t.Errorf("Did not get message 1.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, expectedMessageString, message) } select { case <-time.After(1 * time.Second): t.Errorf("Did not get message 2.") case message := <-receivedChan: messagetesthelpers.AssertProtoBufferMessageEquals(t, otherMessageString, message) } dontKeepAliveChan <- true }
func TestDumpWithLotsOfMessagesAndLargeBuffer(t *testing.T) { var bufferSize uint bufferSize = 200 dump := NewDumpSink("myApp", bufferSize, loggertesthelper.Logger()) dump.Run() for i := 0; i < 1000; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") dump.Channel() <- logMessage } runtime.Gosched() logMessages := dumpAllMessages(dump, bufferSize) assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "801") for i := 1000; i < 2000; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") dump.Channel() <- logMessage } runtime.Gosched() logMessages = dumpAllMessages(dump, bufferSize) assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801") logMessages = dumpAllMessages(dump, bufferSize) assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801") }
func TestSendingToErrorChannelDoesNotBlock(t *testing.T) { testMessageRouter := NewMessageRouter(1024, false, nil, loggertesthelper.Logger()) testMessageRouter.errorChannel = make(chan *logmessage.Message, 1) go testMessageRouter.Start() sinkChannel := make(chan *logmessage.Message, 10) ourSink := testSink{sinkChannel, false} testMessageRouter.sinkOpenChan <- ourSink <-time.After(1 * time.Millisecond) for i := 0; i < 10; i++ { badMessage := messagetesthelpers.NewMessage(t, "error msg", "appIdWeDontCareAbout") badMessage.GetLogMessage().DrainUrls = []string{fmt.Sprintf("<nil%d>", i)} testMessageRouter.parsedMessageChan <- badMessage } goodMessage := messagetesthelpers.NewMessage(t, "error msg", "appId") testMessageRouter.parsedMessageChan <- goodMessage select { case _ = <-ourSink.Channel(): case <-time.After(1000 * time.Millisecond): t.Error("Should have received a message") } }
func TestDumpReturnsAllRecentMessagesToMultipleDumpRequestsWithMessagesCloningInInTheMeantime(t *testing.T) { dump := NewDumpSink("myApp", 2, loggertesthelper.Logger(), make(chan Sink, 1), time.Second) go dump.Run() logMessage := messagetesthelpers.NewMessage(t, "1", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "3", "appId") dump.Channel() <- logMessage runtime.Gosched() logMessages := dump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") logMessage = messagetesthelpers.NewMessage(t, "4", "appId") dump.Channel() <- logMessage runtime.Gosched() logMessages = dump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "3") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "4") }
func TestDumpsMostRecentMessagesWithSmallerOutputChan(t *testing.T) { var bufferSize uint bufferSize = 4 dump := NewDumpSink("myApp", bufferSize, loggertesthelper.Logger()) dump.Run() logMessage := messagetesthelpers.NewMessage(t, "1", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "3", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "4", "appId") dump.Channel() <- logMessage runtime.Gosched() receivedChan := make(chan *logmessage.Message, 2) dump.Dump(receivedChan) firstMessage := <-receivedChan assert.Equal(t, string(firstMessage.GetLogMessage().GetMessage()), "3") secondMessage := <-receivedChan assert.Equal(t, string(secondMessage.GetLogMessage().GetMessage()), "4") }
func TestDumpWithLotsOfMessages(t *testing.T) { dump := NewDumpSink("myApp", 2, loggertesthelper.Logger()) for i := 0; i < 100; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") dump.Channel() <- logMessage } runtime.Gosched() logMessages := dumpAllMessages(dump) assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "98") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "99") for i := 100; i < 200; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") dump.Channel() <- logMessage } runtime.Gosched() logMessages = dumpAllMessages(dump) assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "198") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "199") logMessages = dumpAllMessages(dump) assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "198") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "199") }
func TestStopsRetryingWhenSinkIsUnregistered(t *testing.T) { testMessageRouter := NewMessageRouter(1024, false, []iprange.IPRange{iprange.IPRange{Start: "10.10.123.1", End: "10.10.123.1"}}, loggertesthelper.Logger()) go testMessageRouter.Start() ourSink := testSink{make(chan *logmessage.Message, 100), true} testMessageRouter.sinkOpenChan <- ourSink runtime.Gosched() go func() { message := messagetesthelpers.NewMessage(t, "error msg", "appId") message.GetLogMessage().DrainUrls = []string{"syslog://localhost:41223"} testMessageRouter.parsedMessageChan <- message newMessage := messagetesthelpers.NewMessage(t, "RemoveSyslogSink", "appId") testMessageRouter.parsedMessageChan <- newMessage }() for { readMessage := <-ourSink.Channel() if string(readMessage.GetLogMessage().GetMessage()) == "RemoveSyslogSink" { break } } select { case message := <-ourSink.Channel(): t.Errorf("Should not receive another message after removal; message was %v", string(message.GetLogMessage().GetMessage())) case <-time.After(2 * time.Second): } }
func TestDumpReturnsAllRecentMessagesToMultipleDumpRequests(t *testing.T) { testDump := dump.NewDumpSink("myApp", 2, loggertesthelper.Logger(), time.Second) dumpRunnerDone := make(chan struct{}) inputChan := make(chan *logmessage.Message) go func() { testDump.Run(inputChan) close(dumpRunnerDone) }() logMessage := messagetesthelpers.NewMessage(t, "1", "appId") inputChan <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") inputChan <- logMessage logMessage = messagetesthelpers.NewMessage(t, "3", "appId") inputChan <- logMessage close(inputChan) <-dumpRunnerDone logMessages := testDump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") logMessages = testDump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") }
func TestDumpWithLotsOfMessagesAndLargeBuffer(t *testing.T) { dump := NewDumpSink("myApp", 200, loggertesthelper.Logger(), make(chan Sink, 1), time.Second) go dump.Run() for i := 0; i < 1000; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") dump.Channel() <- logMessage } runtime.Gosched() logMessages := dump.Dump() assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "801") for i := 1000; i < 2000; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") dump.Channel() <- logMessage } runtime.Gosched() logMessages = dump.Dump() assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801") logMessages = dump.Dump() assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801") }
func TestDumpAlwaysReturnsTheNewestMessages(t *testing.T) { dump := NewDumpSink("myApp", 2, loggertesthelper.Logger(), time.Second, fakeTimeProvider) dumpRunnerDone := make(chan struct{}) inputChan := make(chan *logmessage.Message) go func() { dump.Run(inputChan) close(dumpRunnerDone) }() logMessage := messagetesthelpers.NewMessage(t, "1", "appId") inputChan <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") inputChan <- logMessage logMessage = messagetesthelpers.NewMessage(t, "3", "appId") inputChan <- logMessage close(inputChan) <-dumpRunnerDone logMessages := dump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") }
func TestSimpleBlacklistRule(t *testing.T) { logger := loggertesthelper.Logger() sinkManager := NewSinkManager(1024, false, []iprange.IPRange{iprange.IPRange{Start: "10.10.123.1", End: "10.10.123.1"}}, logger) oldActiveSyslogSinksCounter := sinkManager.Metrics.SyslogSinks go sinkManager.Start() incomingLogChan := make(chan []byte, 10) testMessageRouter := NewMessageRouter(incomingLogChan, testhelpers.UnmarshallerMaker("secret"), sinkManager, 2048, logger) go testMessageRouter.Start() ourSink := testSink{make(chan *logmessage.Message, 100), true} sinkManager.sinkOpenChan <- ourSink <-time.After(1 * time.Millisecond) message := messagetesthelpers.NewMessage(t, "error msg", "appId") message.GetLogMessage().DrainUrls = []string{"http://10.10.123.1"} testMessageRouter.outgoingLogChan <- message select { case _ = <-ourSink.Channel(): case <-time.After(100 * time.Millisecond): t.Error("Did not receive real message") } select { case _ = <-ourSink.Channel(): case <-time.After(100 * time.Millisecond): t.Error("Did not message about blacklisted syslog drain") } testMessageRouter.outgoingLogChan <- message select { case _ = <-ourSink.Channel(): case <-time.After(100 * time.Millisecond): t.Error("Did not receive real message") } select { case _ = <-ourSink.Channel(): t.Error("Should not receive another message about the blacklisted url since we cache blacklisted urls") case <-time.After(100 * time.Millisecond): } assert.Equal(t, sinkManager.Metrics.SyslogSinks, oldActiveSyslogSinksCounter) message = messagetesthelpers.NewMessage(t, "error msg", "appId") message.GetLogMessage().DrainUrls = []string{"http://10.10.123.2"} testMessageRouter.outgoingLogChan <- message waitForMessageGettingProcessed(t, ourSink, 10*time.Millisecond) assert.Equal(t, sinkManager.Metrics.SyslogSinks, oldActiveSyslogSinksCounter+1) }
func TestSysLoggerDiesAndComesBack(t *testing.T) { sysLogger := NewSyslogWriterRecorder() sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger, make(chan *logmessage.Message)) sysLogger.SetUp(true) done := make(chan bool) go func() { sink.Run() done <- true }() msg := fmt.Sprintf("first message") logMessage := messagetesthelpers.NewMessage(t, msg, "appId") sink.Channel() <- logMessage select { case <-sysLogger.receivedChannel: break case <-time.After(10 * time.Millisecond): t.Error("Should have received a message by now") } sysLogger.SetUp(false) assert.Equal(t, len(sysLogger.ReceivedMessages()), 1) for i := 0; i < 11; i++ { msg := fmt.Sprintf("message no %v", i) logMessage := messagetesthelpers.NewMessage(t, msg, "appId") sink.Channel() <- logMessage } sysLogger.SetUp(true) close(sink.Channel()) <-done assert.Equal(t, len(sysLogger.ReceivedMessages()), 11) stringOfMessages := fmt.Sprintf("%v", sysLogger.ReceivedMessages()) assert.Contains(t, stringOfMessages, "first message", "This message should have been there, since the server was up") assert.NotContains(t, stringOfMessages, "out: message no 0", "This message should have been lost because the connection problem was detected while trying to send it.") assert.Contains(t, stringOfMessages, "out: message no 1", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 2", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 3", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 4", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 5", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 6", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 7", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 8", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 9", "This message should have been there, since it was in the ringbuffer while the server was down") assert.Contains(t, stringOfMessages, "out: message no 10", "This message should have been there, since it was in the ringbuffer while the server was down") }
func TestBufferDropsOldMessages(t *testing.T) { channel, buffer := setup(1) message1 := messagetesthelpers.NewMessage(t, "message 1", "appId") channel <- message1 message2 := messagetesthelpers.NewMessage(t, "message 2", "appId") channel <- message2 close(channel) buffer.waitForClose() dump := buffer.Dump() assert.Equal(t, 1, len(dump)) assert.Equal(t, message2, dump[0]) }
func TestDumpWithLotsOfMessagesAndLargeBuffer(t *testing.T) { dump := NewDumpSink("myApp", 200, loggertesthelper.Logger(), time.Second, fakeTimeProvider) dumpRunnerDone := make(chan struct{}) inputChan := make(chan *logmessage.Message) go func() { dump.Run(inputChan) close(dumpRunnerDone) }() for i := 0; i < 1000; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") inputChan <- logMessage } close(inputChan) <-dumpRunnerDone logMessages := dump.Dump() assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "801") dumpRunnerDone = make(chan struct{}) inputChan = make(chan *logmessage.Message) go func() { dump.Run(inputChan) close(dumpRunnerDone) }() for i := 1000; i < 2000; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") inputChan <- logMessage } close(inputChan) <-dumpRunnerDone logMessages = dump.Dump() assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801") logMessages = dump.Dump() assert.Equal(t, len(logMessages), 200) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1800") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "1801") }
func TestDumpWithLotsOfMessages(t *testing.T) { testDump := dump.NewDumpSink("myApp", 2, loggertesthelper.Logger(), time.Second) dumpRunnerDone := make(chan struct{}) inputChan := make(chan *logmessage.Message) go func() { testDump.Run(inputChan) close(dumpRunnerDone) }() for i := 0; i < 100; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") inputChan <- logMessage } close(inputChan) <-dumpRunnerDone logMessages := testDump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "98") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "99") dumpRunnerDone = make(chan struct{}) inputChan = make(chan *logmessage.Message) go func() { testDump.Run(inputChan) close(dumpRunnerDone) }() for i := 100; i < 200; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") inputChan <- logMessage } close(inputChan) <-dumpRunnerDone logMessages = testDump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "198") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "199") logMessages = testDump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "198") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "199") }
func TestThatItWorksLikeAChannel(t *testing.T) { inMessageChan := make(chan *logmessage.Message) buffer := NewTruncatingBuffer(inMessageChan, 2, nil) go buffer.Run() logMessage1 := messagetesthelpers.NewMessage(t, "message 1", "appId") inMessageChan <- logMessage1 readMessage := <-buffer.GetOutputChannel() assert.Contains(t, string(readMessage.GetRawMessage()), "message 1") logMessage2 := messagetesthelpers.NewMessage(t, "message 2", "appId") inMessageChan <- logMessage2 readMessage2 := <-buffer.GetOutputChannel() assert.Contains(t, string(readMessage2.GetRawMessage()), "message 2") }
func TestBufferDropsOldMessages(t *testing.T) { channel, buffer := setup(1) message1 := messagetesthelpers.NewMessage(t, "message 1", "appId") channel <- message1 message2 := messagetesthelpers.NewMessage(t, "message 2", "appId") channel <- message2 close(channel) buffer.WaitForClose() dumpChan := make(chan *logmessage.Message, 10) buffer.Dump(dumpChan) assert.Equal(t, 1, len(dumpChan)) assert.Equal(t, message2, <-dumpChan) }
func TestDumpForTwoMessages(t *testing.T) { dump := NewDumpSink("myApp", 2, loggertesthelper.Logger()) logMessage := messagetesthelpers.NewMessage(t, "1", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") dump.Channel() <- logMessage runtime.Gosched() logMessages := dumpAllMessages(dump) assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "1") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "2") }
func TestInputChannelAddToBuffer(t *testing.T) { channel, buffer := setup(10) message1 := messagetesthelpers.NewMessage(t, "message 1", "appId") channel <- message1 message2 := messagetesthelpers.NewMessage(t, "message 2", "appId") channel <- message2 close(channel) buffer.waitForClose() dump := buffer.Dump() assert.Equal(t, 2, len(dump)) assert.Equal(t, message1, dump[0]) assert.Equal(t, message2, dump[1]) }
func TestSysLoggerComesUpLate(t *testing.T) { sysLogger := NewSyslogWriterRecorder() sysLogger.SetUp(false) sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger) done := make(chan bool) go func() { sink.Run() done <- true }() for i := 0; i < 15; i++ { msg := fmt.Sprintf("message no %v", i) logMessage := messagetesthelpers.NewMessage(t, msg, "appId") sink.Channel() <- logMessage } close(sink.Channel()) sysLogger.SetUp(true) <-done data := sysLogger.ReceivedMessages() assert.Equal(t, len(data), 10) for i := 0; i < 10; i++ { msg := fmt.Sprintf("out: message no %v", i+5) assert.Equal(t, data[i], msg) } }
func xTestDumpSinkClosingTimeIsResetWhenAMessageArrives(t *testing.T) { dump := NewDumpSink("myApp", 5, loggertesthelper.Logger(), 10*time.Millisecond, fakeTimeProvider) dumpRunnerDone := make(chan struct{}) inputChan := make(chan *logmessage.Message) go func() { dump.Run(inputChan) close(dumpRunnerDone) }() fakeTimeProvider.IncrementBySeconds(uint64(5)) logMessage := messagetesthelpers.NewMessage(t, "0", "appId") inputChan <- logMessage fakeTimeProvider.IncrementBySeconds(uint64(8)) fakeTimeProvider.IncrementBySeconds(uint64(3)) select { case sink := <-dumpRunnerDone: assert.Equal(t, sink, dump) case <-time.After(5 * time.Millisecond): assert.Fail(t, "Should have closed") } }
func TestSinkReportsErrorsOnTheErrorChannel(t *testing.T) { sysLogger := NewSyslogWriterRecorder() sysLogger.SetUp(false) errorChannel := make(chan *logmessage.Message, 10) sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger, errorChannel) done := make(chan bool) go func() { sink.Run() done <- true }() msg := fmt.Sprintf("first message") logMessage := messagetesthelpers.NewMessage(t, msg, "appId") sink.Channel() <- logMessage select { case errorLog := <-errorChannel: errorMsg := string(errorLog.GetLogMessage().GetMessage()) assert.Contains(t, errorMsg, "Syslog Sink url_not_used: Error when dialing out. Backing off for") assert.Contains(t, errorMsg, "Err: Error connecting.") assert.Equal(t, errorLog.GetLogMessage().GetSourceName(), "LGR") case <-time.After(10 * time.Millisecond): t.Error("Should have received an error message by now") } }
func TestDumpWithLotsOfDumps(t *testing.T) { runtime.GOMAXPROCS(runtime.NumCPU()) dump := NewDumpSink("myApp", 5, loggertesthelper.Logger(), time.Second, fakeTimeProvider) dumpRunnerDone := make(chan struct{}) inputChan := make(chan *logmessage.Message) go func() { dump.Run(inputChan) close(dumpRunnerDone) }() for i := 0; i < 10; i++ { logMessage := messagetesthelpers.NewMessage(t, strconv.Itoa(i), "appId") inputChan <- logMessage } close(inputChan) <-dumpRunnerDone for i := 0; i < 200; i++ { go func() { logMessages := dump.Dump() assert.Equal(t, len(logMessages), 5) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "5") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "6") }() } }
func TestThatItDoesNotCreateAnotherSyslogDrainIfItIsAlreadyThere(t *testing.T) { logger := loggertesthelper.Logger() sinkManager := NewSinkManager(1024, false, nil, logger) oldActiveSyslogSinksCounter := sinkManager.Metrics.SyslogSinks go sinkManager.Start() incomingLogChan := make(chan []byte, 10) testMessageRouter := NewMessageRouter(incomingLogChan, testhelpers.UnmarshallerMaker("secret"), sinkManager, 2048, logger) go testMessageRouter.Start() ourSink := testSink{make(chan *logmessage.Message, 100), false} sinkManager.sinkOpenChan <- ourSink <-time.After(1 * time.Millisecond) message := messagetesthelpers.NewMessage(t, "error msg", "appId") message.GetLogMessage().DrainUrls = []string{"http://10.10.123.1"} testMessageRouter.outgoingLogChan <- message waitForMessageGettingProcessed(t, ourSink, 10*time.Millisecond) assert.Equal(t, sinkManager.Metrics.SyslogSinks, oldActiveSyslogSinksCounter+1) testMessageRouter.outgoingLogChan <- message waitForMessageGettingProcessed(t, ourSink, 10*time.Millisecond) assert.Equal(t, sinkManager.Metrics.SyslogSinks, oldActiveSyslogSinksCounter+1) }
func TestBufferHasChannelListenerWithLimitOne(t *testing.T) { inChannel, buffer := setup(1) message1 := messagetesthelpers.NewMessage(t, "message 1", "appId") inChannel <- message1 message2 := messagetesthelpers.NewMessage(t, "message 2", "appId") inChannel <- message2 message3 := messagetesthelpers.NewMessage(t, "message 3", "appId") inChannel <- message3 close(inChannel) assert.Equal(t, message3, <-buffer.OutputChannel()) select { case <-buffer.OutputChannel(): case <-time.After(2 * time.Millisecond): t.Error("OutputChannel should be closed") } }
func TestSysLoggerComesUpLate(t *testing.T) { sysLogger := NewSyslogWriterRecorder() sysLogger.SetUp(false) sink := NewSyslogSink("appId", "url_not_used", loggertesthelper.Logger(), sysLogger, make(chan *logmessage.Message, 10)) done := make(chan bool) go func() { sink.Run() done <- true }() for i := 0; i < 105; i++ { msg := fmt.Sprintf("message no %v", i) logMessage := messagetesthelpers.NewMessage(t, msg, "appId") sink.Channel() <- logMessage } close(sink.Channel()) sysLogger.SetUp(true) <-done data := sysLogger.ReceivedMessages() assert.Equal(t, len(data), 6) msg := "err: Log message output too high. We've dropped 100 messages" assert.Equal(t, data[0], msg) for i := 0; i < 5; i++ { msg := fmt.Sprintf("out: message no %v", i+100) assert.Equal(t, data[i+1], msg) } }
func TestThatItWorksLikeAChannel(t *testing.T) { inMessageChan := make(chan *logmessage.Message) outMessageChan := make(chan *logmessage.Message, 2) ringBufferChannel := NewRingBuffer(inMessageChan, outMessageChan, nil) go ringBufferChannel.Run() logMessage1 := messagetesthelpers.NewMessage(t, "message 1", "appId") inMessageChan <- logMessage1 readMessage := <-outMessageChan assert.Contains(t, string(readMessage.GetRawMessage()), "message 1") logMessage2 := messagetesthelpers.NewMessage(t, "message 2", "appId") inMessageChan <- logMessage2 readMessage2 := <-outMessageChan assert.Contains(t, string(readMessage2.GetRawMessage()), "message 2") }
func TestTheDumpSinkNeverFillsUp(t *testing.T) { bufferSize := 3 dump := NewDumpSink("myApp", bufferSize, loggertesthelper.Logger()) logMessage := messagetesthelpers.NewMessage(t, "hi", "appId") for i := 0; i < bufferSize+1; i++ { dump.Channel() <- logMessage } }
func TestDumpAlwaysReturnsTheNewestMessages(t *testing.T) { dump := NewDumpSink("myApp", 2, loggertesthelper.Logger(), make(chan Sink, 1), time.Second) go dump.Run() logMessage := messagetesthelpers.NewMessage(t, "1", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "2", "appId") dump.Channel() <- logMessage logMessage = messagetesthelpers.NewMessage(t, "3", "appId") dump.Channel() <- logMessage runtime.Gosched() logMessages := dump.Dump() assert.Equal(t, len(logMessages), 2) assert.Equal(t, string(logMessages[0].GetLogMessage().GetMessage()), "2") assert.Equal(t, string(logMessages[1].GetLogMessage().GetMessage()), "3") }