})
		})

		It("marshals events and delegates to the inner emitter", func() {
			innerEmitter := fake.NewFakeByteEmitter()
			origin := "fake-origin"
			eventEmitter := emitter.NewEventEmitter(innerEmitter, origin)

			testEvent := factories.NewHeartbeat(1, 2, 3)
			err := eventEmitter.Emit(testEvent)
			Expect(err).ToNot(HaveOccurred())

			Expect(innerEmitter.GetMessages()).To(HaveLen(1))
			msg := innerEmitter.GetMessages()[0]

			var envelope events.Envelope
			err = proto.Unmarshal(msg, &envelope)
			Expect(err).ToNot(HaveOccurred())
			Expect(envelope.GetEventType()).To(Equal(events.Envelope_Heartbeat))
		})
	})

	Describe("Close", func() {
		It("closes the inner emitter", func() {
			innerEmitter := fake.NewFakeByteEmitter()
			eventEmitter := emitter.NewEventEmitter(innerEmitter, "")

			eventEmitter.Close()
			Expect(innerEmitter.IsClosed()).To(BeTrue())
		})
	})
			lock := sync.RWMutex{}
			origin := os.Getenv("DROPSONDE_ORIGIN")

			go func() {
				defer close(udpDataChan)
				for {
					buffer := make([]byte, 1024)
					n, _, err := udpListener.ReadFrom(buffer)
					if err != nil {
						return
					}

					if n == 0 {
						panic("Received empty packet")
					}
					envelope := new(events.Envelope)
					err = proto.Unmarshal(buffer[0:n], envelope)
					if err != nil {
						panic(err)
					}

					var eventId = envelope.GetEventType().String()

					switch envelope.GetEventType() {
					case events.Envelope_HttpStart:
						eventId += envelope.GetHttpStart().GetPeerType().String()
					case events.Envelope_HttpStop:
						eventId += envelope.GetHttpStop().GetPeerType().String()
					case events.Envelope_Heartbeat:
					case events.Envelope_ValueMetric:
						eventId += envelope.GetValueMetric().GetName()
func GetAppId(envelope *events.Envelope) string {
	if envelope.GetEventType() == events.Envelope_LogMessage {
		return envelope.GetLogMessage().GetAppId()
	}

	if envelope.GetEventType() == events.Envelope_ContainerMetric {
		return envelope.GetContainerMetric().GetApplicationId()
	}

	var event hasAppId
	switch envelope.GetEventType() {
	case events.Envelope_HttpStart:
		event = envelope.GetHttpStart()
	case events.Envelope_HttpStop:
		event = envelope.GetHttpStop()
	case events.Envelope_HttpStartStop:
		event = envelope.GetHttpStartStop()
	default:
		return SystemAppId
	}

	uuid := event.GetApplicationId()
	if uuid != nil {
		return formatUUID(uuid)
	}
	return SystemAppId
}
					buffer := make([]byte, 1024)
					n, addr, err := udpListener.ReadFrom(buffer)
					if err != nil {
						return
					}

					if !requestedHeartbeat {

						udpListener.WriteTo(marshalledHeartbeatRequest, addr)
						requestedHeartbeat = true
					}

					if n == 0 {
						panic("Received empty packet")
					}
					envelope := new(events.Envelope)
					err = proto.Unmarshal(buffer[0:n], envelope)
					if err != nil {
						panic(err)
					}

					var eventId = envelope.GetEventType().String()

					switch envelope.GetEventType() {
					case events.Envelope_HttpStart:
						eventId += envelope.GetHttpStart().GetPeerType().String()
					case events.Envelope_HttpStop:
						eventId += envelope.GetHttpStop().GetPeerType().String()
					case events.Envelope_Heartbeat:
						heartbeatUuidsChan <- envelope.GetHeartbeat().GetControlMessageIdentifier().String()
					case events.Envelope_ValueMetric:
		It("creates a Heartbeat message", func() {
			id, _ := uuid.NewV4()

			heartbeatRequest := &control.ControlMessage{
				Origin:      proto.String("tst"),
				Identifier:  factories.NewControlUUID(id),
				Timestamp:   proto.Int64(time.Now().UnixNano()),
				ControlType: control.ControlMessage_HeartbeatRequest.Enum(),
			}

			heartbeatResponder.Respond(heartbeatRequest)
			Expect(wrappedEmitter.GetMessages()).To(HaveLen(1))
			hbBytes := wrappedEmitter.GetMessages()[0]

			var heartbeat events.Envelope
			err := proto.Unmarshal(hbBytes, &heartbeat)
			Expect(err).NotTo(HaveOccurred())

			heartbeatUuid := heartbeatRequest.GetIdentifier().String()
			Expect(heartbeat.GetHeartbeat().ControlMessageIdentifier.String()).To(Equal(heartbeatUuid))
		})

		It("logs an error when heartbeat emission fails", func() {
			wrappedEmitter.ReturnError = errors.New("fake error")

			logWriter := new(bytes.Buffer)
			log.SetOutput(logWriter)

			id, _ := uuid.NewV4()