func (u *DropsondeUnmarshaller) UnmarshallMessage(message []byte) (*events.Envelope, error) {
envelope := &events.Envelope{}
err := proto.Unmarshal(message, envelope)
if err != nil {
logging.Debugf(u.logger, "dropsondeUnmarshaller: unmarshal error %v ", err)
metrics.BatchIncrementCounter("dropsondeUnmarshaller.unmarshalErrors")
return nil, err
}
if err := u.incrementReceiveCount(envelope.GetEventType()); err != nil {
logging.Debugf(u.logger, err.Error())
return nil, err
}
return envelope, nil
}
func (m *MessageAggregator) handleHTTPStart(envelope *events.Envelope) {
metrics.BatchIncrementCounter("MessageAggregator.httpStartReceived")
logging.Debugf(m.logger, "handling HTTP start message for appID: %v", envelope.GetHttpStart().GetApplicationId())
startEvent := envelope.GetHttpStart()
requestID := startEvent.RequestId.String()
event := eventID{requestID: requestID, peerType: startEvent.GetPeerType()}
m.startEventsByEventID[event] = startEventEntry{startEvent: startEvent, entryTime: time.Now()}
}
func (f *Finder) handleEvent(event *storeadapter.WatchEvent, parser func([]byte) (interface{}, error)) {
switch event.Type {
case storeadapter.InvalidEvent:
f.logger.Errorf("Received invalid event: %+v", event)
return
case storeadapter.UpdateEvent:
if bytes.Equal(event.PrevNode.Value, event.Node.Value) {
return
}
fallthrough
case storeadapter.CreateEvent:
logging.Debugf(f.logger, "Received create/update event: %+v", event.Type)
f.saveEndpoints(f.parseNode(*event.Node, parser))
case storeadapter.DeleteEvent, storeadapter.ExpireEvent:
logging.Debugf(f.logger, "Received delete/expire event: %+v", event.Type)
f.deleteEndpoints(f.parseNode(*event.PrevNode, parser))
}
f.sendEvent()
}
func (c *udpClient) Write(data []byte) (int, error) {
if len(data) == 0 {
return 0, nil
}
writeCount, err := c.conn.WriteTo(data, c.addr)
if err != nil {
c.logger.Errorf("Writing to loggregator %s failed %s", c.Address(), err)
return writeCount, err
}
logging.Debugf(c.logger, "Wrote %d bytes to %s", writeCount, c.Address())
return writeCount, err
}
func (m *MessageAggregator) handleHTTPStop(envelope *events.Envelope) *events.Envelope {
metrics.BatchIncrementCounter("MessageAggregator.httpStopReceived")
logging.Debugf(m.logger, "handling HTTP stop message for appID: %v", envelope.GetHttpStop().GetApplicationId())
stopEvent := envelope.GetHttpStop()
requestID := stopEvent.RequestId.String()
event := eventID{requestID: requestID, peerType: stopEvent.GetPeerType()}
startEventEntry, ok := m.startEventsByEventID[event]
if !ok {
m.logger.Warnf("no matching HTTP start message found for appID: %v", envelope.GetHttpStop().GetApplicationId())
metrics.BatchIncrementCounter("MessageAggregator.httpUnmatchedStopReceived")
return nil
}
metrics.BatchIncrementCounter("MessageAggregator.httpStartStopEmitted")
delete(m.startEventsByEventID, event)
startEvent := startEventEntry.startEvent
return &events.Envelope{
Origin: envelope.Origin,
Timestamp: stopEvent.Timestamp,
EventType: events.Envelope_HttpStartStop.Enum(),
HttpStartStop: &events.HttpStartStop{
StartTimestamp: startEvent.Timestamp,
StopTimestamp: stopEvent.Timestamp,
RequestId: startEvent.RequestId,
PeerType: startEvent.PeerType,
Method: startEvent.Method,
Uri: startEvent.Uri,
RemoteAddress: startEvent.RemoteAddress,
UserAgent: startEvent.UserAgent,
StatusCode: stopEvent.StatusCode,
ContentLength: stopEvent.ContentLength,
ParentRequestId: startEvent.ParentRequestId,
ApplicationId: stopEvent.ApplicationId,
InstanceIndex: startEvent.InstanceIndex,
InstanceId: startEvent.InstanceId,
},
}
}
func (nr *NetworkReader) Start() {
receivedMessageCountName := nr.contextName + ".receivedMessageCount"
receivedByteCountName := nr.contextName + ".receivedByteCount"
readBuffer := make([]byte, 65535) //buffer with size = max theoretical UDP size
for {
readCount, senderAddr, err := nr.connection.ReadFrom(readBuffer)
if err != nil {
nr.logger.Errorf("Error while reading. %s", err)
return
}
logging.Debugf(nr.logger, "NetworkReader: Read %d bytes from address %s", readCount, senderAddr)
readData := make([]byte, readCount) //pass on buffer in size only of read data
copy(readData, readBuffer[:readCount])
metrics.BatchIncrementCounter(receivedMessageCountName)
metrics.BatchAddCounter(receivedByteCountName, uint64(readCount))
nr.writer.Write(readData)
}
}
func (u *EventUnmarshaller) UnmarshallMessage(message []byte) (*events.Envelope, error) {
envelope := &events.Envelope{}
err := proto.Unmarshal(message, envelope)
if err != nil {
u.logger.Errorf("eventUnmarshaller: unmarshal error %v", err)
metrics.BatchIncrementCounter("dropsondeUnmarshaller.unmarshalErrors")
return nil, err
}
if !valid(envelope) {
logging.Debugf(u.logger, "eventUnmarshaller: validation failed for message %v", envelope.GetEventType())
metrics.BatchIncrementCounter("dropsondeUnmarshaller.unmarshalErrors")
return nil, invalidEnvelope
}
if err := u.incrementReceiveCount(envelope.GetEventType()); err != nil {
u.logger.Debug(err.Error())
return nil, err
}
return envelope, nil
}
func (c *UDPClient) Write(data []byte) (int, error) {
if len(data) == 0 {
return 0, nil
}
if c.conn == nil {
return 0, errors.New("No connection present.")
}
writeCount, err := c.conn.Write(data)
if err != nil {
c.logger.Errorf("Writing to loggregator %s failed %s", c.Address(), err)
// Log message pulled in from legacy dopplerforwarder code.
c.logger.Debugd(map[string]interface{}{
"scheme": c.Scheme(),
"address": c.Address(),
}, "UDPClient: Error writing legacy message")
return writeCount, err
}
logging.Debugf(c.logger, "Wrote %d bytes to %s", writeCount, c.Address())
return writeCount, err
}
