go uptimeMonitor.Start()
})
AfterEach(func() {
fakeEventEmitter.Close()
})
Context("stops automatically", func() {
AfterEach(func() {
uptimeMonitor.Stop()
})
It("returns a value metric containing uptime after specified time", func() {
Eventually(fakeEventEmitter.GetMessages).Should(HaveLen(1))
Expect(fakeEventEmitter.GetMessages()[0].Event.(*events.ValueMetric)).To(Equal(&events.ValueMetric{
Name: proto.String("Uptime"),
Value: proto.Float64(0),
Unit: proto.String("seconds"),
}))
})
It("reports increasing uptime value", func() {
Eventually(fakeEventEmitter.GetMessages).Should(HaveLen(1))
Expect(fakeEventEmitter.GetMessages()[0].Event.(*events.ValueMetric)).To(Equal(&events.ValueMetric{
Name: proto.String("Uptime"),
Value: proto.Float64(0),
Unit: proto.String("seconds"),
}))
Eventually(getLatestUptime).Should(Equal(1.0))
Describe("event emission", func() {
var requestId *uuid.UUID
BeforeEach(func() {
requestId, _ = uuid.NewV4()
req.Header.Set("X-CF-RequestID", requestId.String())
})
Context("without an application ID or instanceIndex", func() {
BeforeEach(func() {
h.ServeHTTP(httptest.NewRecorder(), req)
})
It("should emit a start event with the right origin", func() {
Expect(fakeEmitter.GetMessages()[0].Event).To(BeAssignableToTypeOf(new(events.HttpStart)))
Expect(fakeEmitter.GetMessages()[0].Origin).To(Equal("testHandler/41"))
})
It("should emit a stop event", func() {
Expect(fakeEmitter.GetMessages()[1].Event).To(BeAssignableToTypeOf(new(events.HttpStop)))
stopEvent := fakeEmitter.GetMessages()[1].Event.(*events.HttpStop)
Expect(stopEvent.GetStatusCode()).To(BeNumerically("==", 123))
Expect(stopEvent.GetContentLength()).To(BeNumerically("==", 12))
})
})
})
Describe("satisfaction of interfaces", func() {
var (
close(runDone)
}()
}
var getMetricNames = func() []string {
var names []string
for _, event := range fakeEventEmitter.GetEvents() {
names = append(names, event.(*events.ValueMetric).GetName())
}
return names
}
It("periodically emits events", func() {
perform()
Eventually(func() int { return len(fakeEventEmitter.GetMessages()) }).Should(BeNumerically(">=", 2))
})
It("emits a NumCpu metric", func() {
perform()
Eventually(fakeEventEmitter.GetEvents).Should(ContainElement(&events.ValueMetric{
Name: proto.String("numCPUS"),
Value: proto.Float64(float64(runtime.NumCPU())),
Unit: proto.String("count"),
}))
})
It("emits a NumGoRoutines metric", func() {
perform()
It("logs the dropped messages", func() {
logMessageNotification := <-buffer.GetOutputChannel()
Expect(logMessageNotification.GetEventType()).To(Equal(events.Envelope_LogMessage))
Expect(logMessageNotification.GetLogMessage().GetMessage()).To(ContainSubstring(fmt.Sprintf("Log message output is too high. %d messages dropped (Total %d messages dropped) to test-sink-name.", delta, total)))
counterEventNotification := <-buffer.GetOutputChannel()
Expect(counterEventNotification.GetEventType()).To(Equal(events.Envelope_CounterEvent))
counterEvent := counterEventNotification.GetCounterEvent()
Expect(counterEvent.GetName()).To(Equal("TruncatingBuffer.DroppedMessages"))
Expect(counterEvent.GetDelta()).To(BeEquivalentTo(delta))
Expect(counterEvent.GetTotal()).To(BeEquivalentTo(total))
})
It("keeps track of dropped messages", func() {
Eventually(fakeEventEmitter.GetMessages).Should(HaveLen(1))
Expect(fakeEventEmitter.GetMessages()[0].Event.(*events.CounterEvent)).To(Equal(&events.CounterEvent{
Name: proto.String("TruncatingBuffer.totalDroppedMessages"),
Delta: proto.Uint64(uint64(total)),
}))
})
}
Context("when the buffer fills once", func() {
JustBeforeEach(func() {
Expect(buffer.GetDroppedMessageCount()).To(BeZero())
firstBuffer := buffer.GetOutputChannel()
sendLogMessages("message 1", inMessageChan)
sendLogMessages("message 2", inMessageChan)
sendLogMessages("message 3", inMessageChan)
sendLogMessages("message 4", inMessageChan)
Expect(readMessage.GetLogMessage().GetMessage()).To(ContainSubstring("message 1"))
sendLogMessages("message 2", inMessageChan)
Eventually(buffer.GetOutputChannel).Should(Receive(&readMessage))
Expect(readMessage.GetLogMessage().GetMessage()).To(ContainSubstring("message 2"))
})
Context("tracking dropped messages", func() {
var fakeEventEmitter *fake.FakeEventEmitter
receiveDroppedMessages := func() uint64 {
var t uint64
for i, _ := range fakeEventEmitter.GetMessages() {
e := fakeEventEmitter.GetMessages()[i].Event.(*events.CounterEvent)
t += e.GetDelta()
}
return t
}
tracksDroppedMessagesAnd := func(itMsg string, delta, total int) {
It(itMsg, func() {
var logMessageNotification *events.Envelope
Eventually(buffer.GetOutputChannel).Should(Receive(&logMessageNotification))
Expect(logMessageNotification.GetEventType()).To(Equal(events.Envelope_LogMessage))
Expect(logMessageNotification.GetLogMessage().GetAppId()).To(Equal("fake-app-id"))
Expect(logMessageNotification.GetLogMessage().GetMessage()).To(ContainSubstring(fmt.Sprintf("Log message output is too high. %d messages dropped (Total %d messages dropped) from doppler to test-sink-name.", delta, total)))
It("sends an error when log error messages cannot be emitted", func() {
err := sender.SendAppErrorLog("app-id", "custom-log-error-message", "App", "0")
Expect(err).To(HaveOccurred())
})
})
})
Describe("ScanLogStream", func() {
It("sends lines from stream to emitter", func() {
buf := bytes.NewBufferString("line 1\nline 2\n")
sender.ScanLogStream("someId", "app", "0", buf)
messages := emitter.GetMessages()
Expect(messages).To(HaveLen(2))
log := emitter.Messages[0].Event.(*events.LogMessage)
Expect(log.GetMessage()).To(BeEquivalentTo("line 1"))
Expect(log.GetMessageType()).To(Equal(events.LogMessage_OUT))
Expect(log.GetAppId()).To(Equal("someId"))
Expect(log.GetSourceType()).To(Equal("app"))
Expect(log.GetSourceInstance()).To(Equal("0"))
log = emitter.Messages[1].Event.(*events.LogMessage)
Expect(log.GetMessage()).To(BeEquivalentTo("line 2"))
Expect(log.GetMessageType()).To(Equal(events.LogMessage_OUT))
})
It("logs a message and returns on read errors", func() {
var _ = Describe("MetricSender", func() {
var (
emitter *fake.FakeEventEmitter
sender metric_sender.MetricSender
)
BeforeEach(func() {
emitter = fake.NewFakeEventEmitter("origin")
sender = metric_sender.NewMetricSender(emitter)
})
It("sends a metric to its emitter", func() {
err := sender.SendValue("metric-name", 42, "answers")
Expect(err).NotTo(HaveOccurred())
Expect(emitter.GetMessages()).To(HaveLen(1))
metric := emitter.GetMessages()[0].Event.(*events.ValueMetric)
Expect(metric.GetName()).To(Equal("metric-name"))
Expect(metric.GetValue()).To(BeNumerically("==", 42))
Expect(metric.GetUnit()).To(Equal("answers"))
})
It("returns an error if it can't send metric value", func() {
emitter.ReturnError = errors.New("some error")
err := sender.SendValue("stuff", 12, "no answer")
Expect(emitter.GetMessages()).To(HaveLen(0))
Expect(err.Error()).To(Equal("some error"))
})
It("sends an update counter event to its emitter", func() {
sender = log_sender.NewLogSender(emitter, loggertesthelper.Logger())
})
AfterEach(func() {
emitter.Close()
for !emitter.IsClosed() {
time.Sleep(10 * time.Millisecond)
}
})
Describe("SendAppLog", func() {
It("sends a log message event to its emitter", func() {
err := sender.SendAppLog("app-id", "custom-log-message", "App", "0")
Expect(err).NotTo(HaveOccurred())
Expect(emitter.GetMessages()).To(HaveLen(1))
log := emitter.GetMessages()[0].Event.(*events.LogMessage)
Expect(log.GetMessageType()).To(Equal(events.LogMessage_OUT))
Expect(log.GetMessage()).To(BeEquivalentTo("custom-log-message"))
Expect(log.GetAppId()).To(Equal("app-id"))
Expect(log.GetSourceType()).To(Equal("App"))
Expect(log.GetSourceInstance()).To(Equal("0"))
Expect(log.GetTimestamp()).ToNot(BeNil())
})
It("totals number of log messages sent to emitter", func() {
sender.SendAppLog("app-id", "custom-log-message", "App", "0")
sender.SendAppLog("app-id", "custom-log-message", "App", "0")
Eventually(emitter.GetEvents).Should(ContainElement(&events.CounterEvent{Name: proto.String("logSenderTotalMessagesRead"), Delta: proto.Uint64(2)}))
})
)
BeforeEach(func() {
envOrigin = "original-origin"
emitter = fake.NewFakeEventEmitter("origin")
sender = envelope_sender.NewEnvelopeSender(emitter)
})
It("sends an Envelope to its emitter", func() {
err := sender.SendEnvelope(createTestEnvelope(envOrigin))
Expect(err).NotTo(HaveOccurred())
Expect(emitter.GetEnvelopes()).To(HaveLen(1))
envelope := emitter.GetEnvelopes()[0]
metric := envelope.ValueMetric
Expect(metric.GetName()).To(Equal("metric-name"))
Expect(metric.GetValue()).To(BeNumerically("==", 42))
Expect(metric.GetUnit()).To(Equal("answers"))
Expect(envelope.Origin).To(Equal(proto.String(envOrigin)))
})
It("returns an error if it can't send metric value", func() {
emitter.ReturnError = errors.New("some error")
err := sender.SendEnvelope(createTestEnvelope(envOrigin))
Expect(emitter.GetMessages()).To(HaveLen(0))
Expect(err.Error()).To(Equal("some error"))
})
})
