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 }