예제 #1
0
func (r *MessageRouter) send(envelope *events.Envelope) {
	appId := envelope_extensions.GetAppId(envelope)

	r.logger.Debugf("MessageRouter:outgoingLogChan: Searching for sinks with appId [%s].", appId)
	r.sinkManager.SendTo(appId, envelope)
	r.logger.Debugf("MessageRouter:outgoingLogChan: Done sending message.")
}
예제 #2
0
func (r *TruncatingBuffer) Run() {
	for msg := range r.inputChannel {
		r.lock.Lock()
		select {
		case r.outputChannel <- msg:
		default:
			messageCount := len(r.outputChannel)
			r.droppedMessageCount += int64(messageCount)
			r.outputChannel = make(chan *events.Envelope, cap(r.outputChannel))
			appId := envelope_extensions.GetAppId(msg)
			lm := generateLogMessage(fmt.Sprintf("Log message output too high. We've dropped %d messages", messageCount), appId)

			env, err := emitter.Wrap(lm, r.dropsondeOrigin)
			if err == nil {
				r.outputChannel <- env
			} else {
				r.logger.Warnf("Error marshalling message: %v", err)
			}

			r.outputChannel <- msg

			if r.logger != nil {
				r.logger.Warn(fmt.Sprintf("TB: Output channel too full. Dropped %d messages for app %s.", messageCount, appId))
			}
		}
		r.lock.Unlock()
	}
	close(r.outputChannel)
}
예제 #3
0
func (sinkManager *SinkManager) listenForErrorMessages() {
	for {
		select {
		case <-sinkManager.doneChannel:
			return
		case errorMessage, ok := <-sinkManager.errorChannel:
			if !ok {
				return
			}
			appId := envelope_extensions.GetAppId(errorMessage)
			sinkManager.logger.Debugf("SinkManager:ErrorChannel: Searching for sinks with appId [%s].", appId)
			sinkManager.sinks.BroadcastError(appId, errorMessage)
			sinkManager.logger.Debugf("SinkManager:ErrorChannel: Done sending error message.")
		}
	}
}
예제 #4
0
func FindMatchingEnvelopeById(id string, msgChan <-chan *events.Envelope) (*events.Envelope, error) {
	timeout := time.After(10 * time.Second)
	for {
		select {
		case receivedEnvelope := <-msgChan:
			receivedId := envelope_extensions.GetAppId(receivedEnvelope)
			if receivedId == id {
				return receivedEnvelope, nil
			} else {
				return nil, errors.New(fmt.Sprintf("Expected messages with app id: %s, got app id: %s", id, receivedId))
			}
		case <-timeout:
			return nil, errors.New("Timed out while waiting for message")
		}
	}
}
			It("puts an error on the message channel when reading messages", func() {
				channelConnector := channel_group_connector.NewChannelGroupConnector(finder, listenerConstructor, marshaller.DropsondeLogMessage, logger)

				stopChan := make(chan struct{})
				defer close(stopChan)
				dopplerEndpoint := doppler_endpoint.NewDopplerEndpoint("stream", "abc123", false)
				go channelConnector.Connect(dopplerEndpoint, messageChan1, stopChan)

				msg := &[]byte{}
				Eventually(messageChan1).Should(Receive(msg))
				envelope := &events.Envelope{}
				err := proto.Unmarshal(*msg, envelope)
				Expect(err).NotTo(HaveOccurred())

				Expect(envelope_extensions.GetAppId(envelope)).To(Equal("abc123"))
				Expect(envelope.GetLogMessage().GetMessage()).To(BeEquivalentTo("proxy: error connecting to 10.0.0.1:1234: failure"))
			})
		})

		Context("when streaming messages from a single server and a listener error occurrs", func() {
			BeforeEach(func() {
				messageChan1 <- expectedMessage1

				fakeListeners[0].SetReadError(errors.New("boom"))

				finder.WebsocketServersOutput.ret0 <- []string{"10.0.0.1:1234"}
			})

			AfterEach(func() {
				for _, l := range fakeListeners {
예제 #6
0
		Eventually(getRecentLogs).Should(ContainElement(env.LogMessage))
	})

	It("sends log messages for a specific app through the stream endpoint", func() {
		msgChan, errorChan := helpers.ConnectToStream("foo")

		helpers.EmitToMetron(createLogEnvelope("Stream message", "bar"))
		helpers.EmitToMetron(createLogEnvelope("Stream message", "foo"))

		receivedEnvelope, err := helpers.FindMatchingEnvelopeById("foo", msgChan)
		Expect(err).NotTo(HaveOccurred())
		Expect(receivedEnvelope).NotTo(BeNil())
		Expect(receivedEnvelope.GetEventType()).To(Equal(events.Envelope_LogMessage))

		event := receivedEnvelope.GetLogMessage()
		Expect(envelope_extensions.GetAppId(receivedEnvelope)).To(Equal("foo"))
		Expect(string(event.GetMessage())).To(Equal("Stream message"))
		Expect(event.GetMessageType().String()).To(Equal(events.LogMessage_OUT.Enum().String()))
		Expect(event.GetTimestamp()).ToNot(BeZero())

		Expect(errorChan).To(BeEmpty())
	})
})

func createLogEnvelope(message, appId string) *events.Envelope {
	return &events.Envelope{
		EventType: events.Envelope_LogMessage.Enum(),
		Origin:    proto.String(helpers.ORIGIN_NAME),
		Timestamp: proto.Int64(time.Now().UnixNano()),
		LogMessage: &events.LogMessage{
			Message:     []byte(message),
func (d *DefaultContext) AppID(envelope *events.Envelope) string {
	return envelope_extensions.GetAppId(envelope)
}
예제 #8
0
			r.Header.Add("User-Agent", "Superman")
			r.Header.Add("X-CF-ApplicationID", id.String())
			done := make(chan struct{})
			handler := instrumented_handler.InstrumentedHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusTeapot)
				close(done)
			}), emitter)

			w := httptest.NewRecorder()
			handler.ServeHTTP(w, r)
			Eventually(done).Should(BeClosed())

			receivedEnvelope, err := helpers.FindMatchingEnvelopeById(id.String(), msgChan)
			Expect(err).NotTo(HaveOccurred())
			Expect(receivedEnvelope).NotTo(BeNil())
			Expect(receivedEnvelope.GetEventType()).To(Equal(events.Envelope_HttpStartStop))

			event := receivedEnvelope.GetHttpStartStop()
			Expect(envelope_extensions.GetAppId(receivedEnvelope)).To(Equal(id.String()))
			Expect(event.GetPeerType().String()).To(Equal(events.PeerType_Server.Enum().String()))
			Expect(event.GetMethod().String()).To(Equal(events.Method_HEAD.Enum().String()))
			Expect(event.GetStartTimestamp()).ToNot(BeZero())
			Expect(event.GetStopTimestamp()).ToNot(BeZero())
			Expect(event.GetUserAgent()).To(Equal("Superman"))
			Expect(event.GetStatusCode()).To(BeEquivalentTo(http.StatusTeapot))

			Expect(errorChan).To(BeEmpty())
		})
	})
})
)

var _ = Describe("EnvelopeExtensions", func() {
	var testAppUuid = &events.UUID{
		Low:  proto.Uint64(1),
		High: proto.Uint64(2),
	}

	Describe("GetAppId", func() {
		Context("HttpStart", func() {
			It("returns the App ID if it has one", func() {
				envelope := &events.Envelope{
					EventType: events.Envelope_HttpStart.Enum(),
					HttpStart: &events.HttpStart{ApplicationId: testAppUuid},
				}
				appId := envelope_extensions.GetAppId(envelope)
				Expect(appId).To(Equal("01000000-0000-0000-0200-000000000000"))
			})

			It("returns system app ID if there isn't an App ID", func() {
				envelope := &events.Envelope{
					EventType: events.Envelope_HttpStart.Enum(),
					HttpStart: &events.HttpStart{},
				}
				appId := envelope_extensions.GetAppId(envelope)
				Expect(appId).To(Equal(envelope_extensions.SystemAppId))
			})
		})

		Context("HttpStop", func() {
			It("returns the App ID if it has one", func() {