func createEnvelope(eventType events.Envelope_EventType) *events.Envelope {
envelope := &events.Envelope{Origin: proto.String("origin"), EventType: &eventType, Timestamp: proto.Int64(time.Now().UnixNano())}
switch eventType {
case events.Envelope_HttpStartStop:
req, _ := http.NewRequest("GET", "http://www.example.com", nil)
req.RemoteAddr = "www.example.com"
req.Header.Add("User-Agent", "user-agent")
uuid, _ := uuid.NewV4()
envelope.HttpStartStop = factories.NewHttpStartStop(req, http.StatusOK, 128, events.PeerType_Client, uuid)
case events.Envelope_ValueMetric:
envelope.ValueMetric = factories.NewValueMetric("some-value-metric", 123, "km")
case events.Envelope_CounterEvent:
envelope.CounterEvent = factories.NewCounterEvent("some-counter-event", 123)
case events.Envelope_LogMessage:
envelope.LogMessage = factories.NewLogMessage(events.LogMessage_OUT, "some message", "appId", "source")
case events.Envelope_ContainerMetric:
envelope.ContainerMetric = factories.NewContainerMetric("appID", 123, 1, 5, 5)
case events.Envelope_Error:
envelope.Error = factories.NewError("source", 123, "message")
default:
panic(fmt.Sprintf("Unknown event %v\n", eventType))
}
return envelope
}
})
It("dumps buffer data to the websocket client with /recentlogs", func(done Done) {
lm, _ := emitter.Wrap(factories.NewLogMessage(events.LogMessage_OUT, "my message", appId, "App"), "origin")
sinkManager.SendTo(appId, lm)
AddWSSink(wsReceivedChan, fmt.Sprintf("ws://%s/apps/%s/recentlogs", apiEndpoint, appId))
rlm, err := receiveEnvelope(wsReceivedChan)
Expect(err).NotTo(HaveOccurred())
Expect(rlm.GetLogMessage().GetMessage()).To(Equal(lm.GetLogMessage().GetMessage()))
close(done)
})
It("dumps container metric data to the websocket client with /containermetrics", func(done Done) {
cm := factories.NewContainerMetric(appId, 0, 42.42, 1234, 123412341234)
envelope, _ := emitter.Wrap(cm, "origin")
sinkManager.SendTo(appId, envelope)
AddWSSink(wsReceivedChan, fmt.Sprintf("ws://%s/apps/%s/containermetrics", apiEndpoint, appId))
rcm, err := receiveEnvelope(wsReceivedChan)
Expect(err).NotTo(HaveOccurred())
Expect(rcm.GetContainerMetric()).To(Equal(cm))
close(done)
})
It("sends data to the websocket client with /stream", func(done Done) {
stopKeepAlive, _ := AddWSSink(wsReceivedChan, fmt.Sprintf("ws://%s/apps/%s/stream", apiEndpoint, appId))
lm, _ := emitter.Wrap(factories.NewLogMessage(events.LogMessage_OUT, "my message", appId, "App"), "origin")
sinkManager.SendTo(appId, lm)
},
}
message, err := proto.Marshal(logMessage)
Expect(err).ToNot(HaveOccurred())
_, err = unmarshaller.UnmarshallMessage(message)
Expect(err).ToNot(HaveOccurred())
Eventually(func() uint64 { return fakeSender.GetCounter("dropsondeUnmarshaller.logMessageTotal") }).Should(BeEquivalentTo(1))
})
Describe("emits counters for", func() {
It("container metrics", func() {
containerMetric := &events.Envelope{
Origin: proto.String("origin"),
EventType: events.Envelope_ContainerMetric.Enum(),
ContainerMetric: factories.NewContainerMetric("appId", 0, 3.0, 23, 23),
}
message, err := proto.Marshal(containerMetric)
Expect(err).ToNot(HaveOccurred())
_, err = unmarshaller.UnmarshallMessage(message)
Expect(err).ToNot(HaveOccurred())
Eventually(func() uint64 { return fakeSender.GetCounter("dropsondeUnmarshaller.containerMetricReceived") }).Should(BeEquivalentTo(1))
})
It("HTTP start event", func() {
uuid, _ := uuid.NewV4()
request, _ := http.NewRequest("GET", "https://example.com", nil)
httpStart := &events.Envelope{
Origin: proto.String("origin"),
EventType: events.Envelope_HttpStart.Enum(),
. "integration_tests/doppler/helpers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
)
var _ = Describe("Container Metrics", func() {
var receivedChan chan []byte
var inputConnection net.Conn
var appID string
itDoesContainerMetrics := func(send func(events.Event, net.Conn) error) {
It("returns container metrics for an app", func() {
containerMetric := factories.NewContainerMetric(appID, 0, 1, 2, 3)
send(containerMetric, inputConnection)
Eventually(dopplerSession).Should(gbytes.Say(`Done sending`))
receivedChan = make(chan []byte)
ws, _ := AddWSSink(receivedChan, "4567", "/apps/"+appID+"/containermetrics")
defer ws.Close()
var receivedMessageBytes []byte
Eventually(receivedChan).Should(Receive(&receivedMessageBytes))
receivedEnvelope := UnmarshalMessage(receivedMessageBytes)
Expect(receivedEnvelope.GetEventType()).To(Equal(events.Envelope_ContainerMetric))
Expect(err).NotTo(HaveOccurred())
err = SendAppLog("otherAppId", "message 2", inputConnection)
Expect(err).NotTo(HaveOccurred())
receivedMessageBytes := []byte{}
Eventually(receivedChan).Should(Receive(&receivedMessageBytes))
receivedMessage := DecodeProtoBufLogMessage(receivedMessageBytes)
Expect(receivedMessage.GetAppId()).To(Equal(appID))
Expect(string(receivedMessage.GetMessage())).To(Equal("message 1"))
Expect(receivedChan).To(BeEmpty())
})
It("does not recieve non-log messages", func() {
metricEvent := factories.NewContainerMetric(appID, 0, 10, 10, 10)
SendEvent(metricEvent, inputConnection)
Expect(receivedChan).To(BeEmpty())
})
It("drops invalid log envelopes", func() {
unmarshalledLogMessage := factories.NewLogMessage(events.LogMessage_OUT, "Some Data", appID, "App")
expectedMessage := MarshalEvent(unmarshalledLogMessage, "invalid")
_, err := inputConnection.Write(expectedMessage)
Expect(err).To(BeNil())
Expect(receivedChan).To(BeEmpty())
})
})
case <-done:
return
}
}
}()
var receivedMessageBytes []byte
Eventually(receiveChan).Should(Receive(&receivedMessageBytes))
close(done)
Expect(DecodeProtoBufEnvelope(receivedMessageBytes).GetEventType()).To(Equal(events.Envelope_LogMessage))
})
It("receives container metrics", func() {
done := make(chan struct{})
containerMetric := factories.NewContainerMetric(appID, 0, 10, 2, 3)
go func() {
for {
SendEvent(containerMetric, inputConnection)
select {
case <-time.After(500 * time.Millisecond):
case <-done:
return
}
}
}()
var receivedMessageBytes []byte
Eventually(receiveChan).Should(Receive(&receivedMessageBytes))
close(done)
Expect(DecodeProtoBufEnvelope(receivedMessageBytes).GetEventType()).To(Equal(events.Envelope_ContainerMetric))
AppId: proto.String("app-id"),
MessageType: events.LogMessage_OUT.Enum(),
SourceType: proto.String("App"),
}
logEvent := factories.NewLogMessage(events.LogMessage_OUT, "hello", "app-id", "App")
Expect(logEvent.GetTimestamp()).ToNot(BeZero())
logEvent.Timestamp = nil
Expect(logEvent).To(Equal(expectedLogEvent))
})
})
Describe("NewContainerMetric", func() {
It("should set the appropriate fields", func() {
expectedContainerMetric := &events.ContainerMetric{
ApplicationId: proto.String("some_app_id"),
InstanceIndex: proto.Int32(7),
CpuPercentage: proto.Float64(42.24),
MemoryBytes: proto.Uint64(1234),
DiskBytes: proto.Uint64(13231231),
}
containerMetric := factories.NewContainerMetric("some_app_id", 7, 42.24, 1234, 13231231)
Expect(containerMetric).To(Equal(expectedContainerMetric))
})
})
})
It("returns correct path for firehose", func() {
dopplerEndpoint := doppler_endpoint.NewDopplerEndpoint("firehose", "subscription-123", true)
Expect(dopplerEndpoint.GetPath()).To(Equal("/firehose/subscription-123"))
})
It("returns correct path for recentlogs", func() {
dopplerEndpoint := doppler_endpoint.NewDopplerEndpoint("recentlogs", "abc123", true)
Expect(dopplerEndpoint.GetPath()).To(Equal("/apps/abc123/recentlogs"))
})
})
var _ = Describe("ContainerMetricsHandler", func() {
It("removes duplicate app container metrics", func() {
messagesChan := make(chan []byte, 2)
env1, _ := emitter.Wrap(factories.NewContainerMetric("1", 1, 123, 123, 123), "origin")
env1.Timestamp = proto.Int64(10000)
env2, _ := emitter.Wrap(factories.NewContainerMetric("1", 1, 123, 123, 123), "origin")
env2.Timestamp = proto.Int64(20000)
bytes1, _ := proto.Marshal(env1)
bytes2, _ := proto.Marshal(env2)
messagesChan <- bytes2
messagesChan <- bytes1
close(messagesChan)
outputChan := doppler_endpoint.DeDupe(messagesChan)
Expect(outputChan).To(HaveLen(1))